diff --git a/doc/changelog.rst b/doc/changelog.rst
index edd6d140..22bdfa86 100644
--- a/doc/changelog.rst
+++ b/doc/changelog.rst
@@ -9,6 +9,10 @@ Changelog
 New
 ~~~
 
+- The step callbacks can now optionally implement a ``pre_hook()``
+  method that will be called before the first step
+  is taken by a ``propagate_*()`` function
+  (`#128 <https://github.com/bluescarni/heyoka.py/pull/128>`__).
 - Introduce several vectorised overloads in the expression
   API. These vectorised overloads allow to perform the same
   operation on a list of expressions more efficiently
@@ -36,6 +40,11 @@ New
 Changes
 ~~~~~~~
 
+- The step callbacks are now deep-copied in multithreaded
+  :ref:`ensemble propagations <ensemble_prop>`
+  rather then being shared among threads. The aim of this change
+  is to reduce the likelihood of data races
+  (`#128 <https://github.com/bluescarni/heyoka.py/pull/128>`__).
 - Comprehensive overhaul of the expression system, including:
   enhanced automatic simplification capabilities for sums,
   products and powers, removal of several specialised primitives
diff --git a/doc/notebooks/Event detection.ipynb b/doc/notebooks/Event detection.ipynb
index a3556aa7..f6803937 100644
--- a/doc/notebooks/Event detection.ipynb	
+++ b/doc/notebooks/Event detection.ipynb	
@@ -143,6 +143,14 @@
     "of the event equation at the trigger time as third argument (-1 for negative derivative, 1 for positive derivative and 0 for\n",
     "zero derivative).\n",
     "\n",
+    "```{note}\n",
+    "\n",
+    "Callbacks are always {func}`deep-copied <copy.deepcopy>` when an event object is created or copied. This behaviour\n",
+    "is meant to help preventing data races in stateful callbacks during multi-threaded {ref}`ensemble propagations<ensemble_prop>`.\n",
+    "You can disable the deep-copying behaviour by providing a custom implementation of the ``__deepcopy__`` method\n",
+    "for the callback, as explained in the documentation of the {mod}`copy` module.\n",
+    "```\n",
+    "\n",
     "Because non-terminal event detection is performed at the end of an integration step,\n",
     "when the callback is invoked the state and time of the integrator object are those *at the end* of the integration\n",
     "step in which the event was detected. This bears repeating, as it is often a source of confusion\n",
@@ -528,7 +536,8 @@
     "\n",
     "- ``callback``: a callback function that will be called when the event triggers. Note that,\n",
     "  for terminal events, the presence of a callback is optional (whereas it is mandatory for\n",
-    "  non-terminal events);\n",
+    "  non-terminal events). Like for non-terminal events, the callback of a terminal event\n",
+    "  (if present) is deep-copied into the event object during construction;\n",
     "- ``cooldown``: a floating-point value representing the cooldown time for the terminal event\n",
     "  (see below for an explanation);\n",
     "- ``direction``: a value of the ``event_direction`` enum which, like for non-terminal\n",
diff --git a/doc/notebooks/The adaptive integrator.ipynb b/doc/notebooks/The adaptive integrator.ipynb
index 82adaa43..04c98d22 100644
--- a/doc/notebooks/The adaptive integrator.ipynb	
+++ b/doc/notebooks/The adaptive integrator.ipynb	
@@ -47,13 +47,13 @@
     {
      "data": {
       "text/plain": [
-       "Tolerance               : 2.2204460492503131e-16\n",
+       "Tolerance               : 2.220446049250313e-16\n",
        "High accuracy           : false\n",
        "Compact mode            : false\n",
        "Taylor order            : 20\n",
        "Dimension               : 2\n",
-       "Time                    : 0.0000000000000000\n",
-       "State                   : [0.050000000000000003, 0.025000000000000001]"
+       "Time                    : 0\n",
+       "State                   : [0.05, 0.025]"
       ]
      },
      "execution_count": 1,
@@ -149,13 +149,13 @@
     {
      "data": {
       "text/plain": [
-       "Tolerance               : 2.2204460492503131e-16\n",
+       "Tolerance               : 2.220446049250313e-16\n",
        "High accuracy           : false\n",
        "Compact mode            : false\n",
        "Taylor order            : 20\n",
        "Dimension               : 2\n",
        "Time                    : 0.21605277478009474\n",
-       "State                   : [0.043996448369926382, -0.078442455470687983]"
+       "State                   : [0.04399644836992638, -0.07844245547068798]"
       ]
      },
      "execution_count": 3,
@@ -257,15 +257,19 @@
     "Before moving on, we need to point out an important caveat when using the single\n",
     "step functions:\n",
     "\n",
-    "> **WARNING**: if the exact solution of the ODE system can be expressed as a polynomial function\n",
-    "> of time, the automatic timestep deduction algorithm may return a timestep of infinity.\n",
-    "> This is the case, for instance, when integrating the rectilinear motion of a free\n",
-    "> particle or the constant-gravity free-fall equation. In such cases, the step functions\n",
-    "> should be called with a finite ``max_delta_t`` argument, in order to clamp the timestep\n",
-    "> to a finite value.\n",
-    ">\n",
-    "> Note that the ``propagate_*()`` functions (described below)\n",
-    "> are not affected by this issue.\n",
+    "```{warning}\n",
+    "\n",
+    "If the exact solution of the ODE system can be expressed as a polynomial function\n",
+    "of time, the automatic timestep deduction algorithm may return a timestep of infinity.\n",
+    "This is the case, for instance, when integrating the rectilinear motion of a free\n",
+    "particle or the constant-gravity free-fall equation. In such cases, the step functions\n",
+    "should be called with a finite ``max_delta_t`` argument, in order to clamp the timestep\n",
+    "to a finite value.\n",
+    "\n",
+    "Note that the ``propagate_*()`` functions (described {ref}`below<time_limited_prop>`)\n",
+    "are not affected by this issue.\n",
+    "\n",
+    "```\n",
     "\n",
     "Accessing state and time\n",
     "------------------------\n",
@@ -340,6 +344,8 @@
    "id": "b6b3e66e",
    "metadata": {},
    "source": [
+    "(time_limited_prop)=\n",
+    "\n",
     "Time-limited propagation\n",
     "------------------------\n",
     "\n",
@@ -432,13 +438,13 @@
       "Num. of steps: 97\n",
       "Current time : 0.0\n",
       "\n",
-      "Tolerance               : 2.2204460492503131e-16\n",
+      "Tolerance               : 2.220446049250313e-16\n",
       "High accuracy           : false\n",
       "Compact mode            : false\n",
       "Taylor order            : 20\n",
       "Dimension               : 2\n",
-      "Time                    : 0.0000000000000000\n",
-      "State                   : [0.050000000000000044, 0.024999999999999991]\n",
+      "Time                    : 0\n",
+      "State                   : [0.050000000000000044, 0.02499999999999999]\n",
       "\n"
      ]
     }
@@ -467,14 +473,15 @@
     "integration will be ``err_nf_state``.\n",
     "\n",
     "The ``propagate_for()`` and ``propagate_until()`` methods\n",
-    "can be invoked with two additional optional keyword arguments:\n",
+    "can be invoked with additional optional keyword arguments:\n",
     "\n",
     "- ``max_delta_t``: similarly to the ``step()`` function, this value\n",
     "  represents the maximum timestep size in absolute value;\n",
     "- ``callback``: this is a callable which will be invoked at the end of\n",
     "  each timestep, with the integrator object as only argument. If the callback returns ``True`` then the integration\n",
     "  will continue after the invocation of the callback, otherwise the integration\n",
-    "  will be interrupted."
+    "  will be interrupted;\n",
+    "- ``c_output``: a boolean flag that enables [continuous output](<./Dense output.ipynb>)."
    ]
   },
   {
@@ -508,6 +515,53 @@
     "ta.propagate_until(t = .5, max_delta_t = .1, callback = cb);"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "676509c9-7002-4a82-a9a9-6c7328c1c741",
+   "metadata": {},
+   "source": [
+    "Optionally, callbacks can implement a ``pre_hook()`` method that will be invoked\n",
+    "once *before* the first step is taken by the ``propagate_for()`` and ``propagate_until()`` methods:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "f9d7051c-7ce7-42cb-8f54-c2b8b77dc5b0",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "pre_hook() invoked!\n",
+      "Current time: 0.6\n",
+      "Current time: 0.7\n",
+      "Current time: 0.8\n",
+      "Current time: 0.9\n",
+      "Current time: 1.0\n",
+      "Current time: 1.1\n",
+      "Current time: 1.2\n",
+      "Current time: 1.3\n",
+      "Current time: 1.4000000000000001\n",
+      "Current time: 1.5\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Callback with pre_hook().\n",
+    "class cb:\n",
+    "    def __call__(self, ta):\n",
+    "        print(\"Current time: {}\".format(ta.time))\n",
+    "        return True\n",
+    "    def pre_hook(self, ta):\n",
+    "        print(\"pre_hook() invoked!\")\n",
+    "\n",
+    "ta.propagate_until(t = 1.5, max_delta_t = .1, callback = cb());"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "45f92420",
@@ -530,7 +584,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "id": "b07369e2",
    "metadata": {},
    "outputs": [
@@ -553,7 +607,7 @@
        "        [-0.04990399, -0.02681336]]))"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -589,7 +643,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "id": "70aac3ac",
    "metadata": {},
    "outputs": [
@@ -616,19 +670,20 @@
     "There are no special requirements on the time values in the grid (apart from the fact that they must be finite and ordered monotonically).\n",
     "\n",
     "The ``propagate_grid()`` method\n",
-    "can be invoked with two additional optional keyword arguments:\n",
+    "can be invoked with additional optional keyword arguments:\n",
     "\n",
     "- ``max_delta_t``: similarly to the ``step()`` function, this value\n",
     "  represents the maximum timestep size in absolute value;\n",
     "- ``callback``: this is a callable which will be invoked at the end of\n",
     "  each timestep, with the integrator object as only argument. If the callback returns ``True`` then the integration\n",
     "  will continue after the invocation of the callback, otherwise the integration\n",
-    "  will be interrupted."
+    "  will be interrupted;\n",
+    "- ``c_output``: a boolean flag that enables [continuous output](<./Dense output.ipynb>)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "id": "4eb16baf-5196-4e8d-9a57-de2ed21ba935",
    "metadata": {},
    "outputs": [
@@ -661,6 +716,51 @@
     "ta.propagate_grid(grid = [1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.],\n",
     "                  max_delta_t = .1, callback = cb);"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c68969fc-344b-4993-8dd9-1a1eeee0588d",
+   "metadata": {},
+   "source": [
+    "Optionally, callbacks can implement a ``pre_hook()`` method that will be invoked\n",
+    "once *before* the first step is taken by the ``propagate_grid()`` method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "e196452a-153a-48ee-a831-f8543345cf75",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "pre_hook() invoked!\n",
+      "Current time: 1.2000000000000002\n",
+      "Current time: 1.3\n",
+      "Current time: 1.4000000000000001\n",
+      "Current time: 1.5\n",
+      "Current time: 1.6\n",
+      "Current time: 1.7000000000000002\n",
+      "Current time: 1.8\n",
+      "Current time: 1.9000000000000001\n",
+      "Current time: 2.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Callback with pre_hook().\n",
+    "class cb:\n",
+    "    def __call__(self, ta):\n",
+    "        print(\"Current time: {}\".format(ta.time))\n",
+    "        return True\n",
+    "    def pre_hook(self, ta):\n",
+    "        print(\"pre_hook() invoked!\")\n",
+    "\n",
+    "ta.propagate_grid(grid = [1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.],\n",
+    "                  max_delta_t = .1, callback = cb());"
+   ]
   }
  ],
  "metadata": {
@@ -679,7 +779,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.13"
+   "version": "3.10.6"
   }
  },
  "nbformat": 4,
diff --git a/doc/notebooks/ensemble_mode.ipynb b/doc/notebooks/ensemble_mode.ipynb
index c3516df8..0caffb2b 100644
--- a/doc/notebooks/ensemble_mode.ipynb
+++ b/doc/notebooks/ensemble_mode.ipynb
@@ -5,6 +5,8 @@
    "id": "7f1e1d69-4db6-4c20-91a2-1bfae5913262",
    "metadata": {},
    "source": [
+    "(ensemble_prop)=\n",
+    "\n",
     "# Ensemble propagations\n",
     "\n",
     "Starting with version 0.17.0, heyoka.py offers support for\n",
@@ -187,17 +189,17 @@
     {
      "data": {
       "text/plain": [
-       "(Tolerance               : 2.2204460492503131e-16\n",
+       "(Tolerance               : 2.220446049250313e-16\n",
        " High accuracy           : false\n",
        " Compact mode            : false\n",
        " Taylor order            : 20\n",
        " Dimension               : 2\n",
-       " Time                    : 20.000000000000000\n",
-       " State                   : [0.053129579044398502, 0.061908760550694837],\n",
+       " Time                    : 20\n",
+       " State                   : [0.039239497771845384, 0.05636215172443391],\n",
        " <taylor_outcome.time_limit: -4294967299>,\n",
-       " 0.1973814707168774,\n",
-       " 0.22082912150625117,\n",
-       " 98,\n",
+       " 0.2085579751630663,\n",
+       " 0.22153023048912757,\n",
+       " 94,\n",
        " None)"
       ]
      },
@@ -219,10 +221,10 @@
     "\n",
     "The ``ensemble_propagate_until()`` function can be invoked with additional optional keyword arguments, beside the mandatory initial 4:\n",
     "\n",
-    "* the ``algorithm`` keyword argument is a string that specifies the parallelisation algorithm that will be used by ``ensemble_propagate_until()``. The supported values are currently ``\"thread\"`` (the default) and ``\"process\"`` (see below for a discussion of the pros and cons of each method);\n",
+    "* the ``algorithm`` keyword argument is a string that specifies the parallelisation algorithm that will be used by ``ensemble_propagate_until()``. The supported values are currently ``\"thread\"`` (the default) and ``\"process\"`` (see {ref}`below<ensemble_thread_vs_proc>` for a discussion of the pros and cons of each method);\n",
     "* the ``max_workers`` keyword argument is an integer that specifies how many workers are spawned during parallelisation. Defaults to ``None``, see the [Python docs](https://docs.python.org/3/library/concurrent.futures.html) for a detailed explanation;\n",
     "* the ``chunksize`` keyword argument is an integer that specifies the size of the tasks that are submitted to the parallel workers. Defaults to 1, see the [Python docs](https://docs.python.org/3/library/concurrent.futures.html) for a detailed explanation.\n",
-    "  This keyword argument can be specified only when using the ``process`` parallelisation method.\n",
+    "  This keyword argument applies only to the ``process`` parallelisation method.\n",
     "\n",
     "Any other keyword argument passed to ``ensemble_propagate_until()`` will be forwarded to the ``propagate_until()`` invocations.\n",
     "\n",
@@ -260,14 +262,12 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 720x360 with 1 Axes>"
+       "<Figure size 1000x500 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -295,6 +295,8 @@
    "id": "9be70417-5214-46ce-9759-539c51344da2",
    "metadata": {},
    "source": [
+    "(ensemble_thread_vs_proc)=\n",
+    "\n",
     "## Choosing between threads and processes\n",
     "\n",
     "Ensemble propagations default to using multiple threads of execution for parallelisation. Multithreading usually performs better than multiprocessing, however there are at least two big caveats to keep in mind when using multithreading:\n",
@@ -303,24 +305,22 @@
     "  the callbacks (if present) are safe for use in a multithreaded context. In particular, the following actions will be performed\n",
     "  concurrently by separate threads of execution:\n",
     "\n",
-    "  * invocation of the generator's call operator and of the call operator\n",
-    "    of the callback that can (optionally) be passed to the ``propagate_*()``\n",
-    "    functions. In other words, both the generator and the ``propagate_*()``\n",
-    "    callback are shared among several threads of execution and used\n",
+    "  * invocation of the generator's call operator. That is, the generator\n",
+    "    is shared among several threads of execution and used\n",
     "    concurrently;\n",
     "  * deep copy of the events callbacks and invocation of the\n",
     "    call operator on the copies. That is, each thread of execution\n",
     "    gets its own copy of the event callbacks thanks to the creation\n",
-    "    of a new integrator object via the generator.\n",
-    "  \n",
+    "    of a new integrator object via the generator;\n",
+    "  * concurrent execution of copies of the step callback, if present.\n",
+    "    That is, before multithreaded execution starts, ``n_iter`` deep copies\n",
+    "    of the step callback (if present) are made, with each iteration in the ensemble\n",
+    "    propagation using its own exclusive copy of the step callback.\n",
+    "    \n",
     "  For instance, an event callback which performs write operations\n",
     "  on a global variable without using some form of synchronisation\n",
     "  will result in unpredictable behaviour when used in an ensemble propagation.\n",
-    "  Similarly, a ``propagate_*()`` callback that\n",
-    "  performs write operations into its own data member(s) without\n",
-    "  synchronisation will also result in a data race, because the\n",
-    "  ``propagate_*()`` callback is shared among several threads;\n",
-    "\n",
+    "  \n",
     "* second, due to the [global interpreter lock (GIL)](https://docs.python.org/3/glossary.html#term-global-interpreter-lock), Python is typically not able to execute code concurrently from multiple threads.\n",
     "  Thus, if a considerable portion of the integration time if spent executing user-defined callbacks, ensemble simulations will exhibit poor parallel speedup.\n",
     "\n",
@@ -349,7 +349,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.12"
+   "version": "3.10.6"
   }
  },
  "nbformat": 4,
diff --git a/doc/notebooks/ex_system_revisited.ipynb b/doc/notebooks/ex_system_revisited.ipynb
index 792597e0..df2c2a37 100644
--- a/doc/notebooks/ex_system_revisited.ipynb
+++ b/doc/notebooks/ex_system_revisited.ipynb
@@ -1403,9 +1403,9 @@
     "\n",
     "In conclusion, how should one choose whether to use ``diff()`` or ``diff_tensors()`` to compute symbolic derivatives in heyoka.py?\n",
     "\n",
-    "``diff()`` should be used when the goal is to produce human-readable symbolic expressions, and when one wants to take advantage of heyoka.py's symbolic simplification capabilities.\n",
+    "In general, ``diff()`` should be used when the goal is to produce human-readable symbolic expressions, and when one wants to take advantage of heyoka.py's symbolic simplification capabilities.\n",
     "\n",
-    "If, however, the goal is to optimise the performance of the numerical evaluation of derivatives, then one should use ``diff_tensors()``."
+    "If, however, the goal is to optimise the performance of the numerical evaluation of derivatives, then one should consider using ``diff_tensors()`` instead."
    ]
   }
  ],
diff --git a/heyoka/CMakeLists.txt b/heyoka/CMakeLists.txt
index 9d752868..5a554f6a 100644
--- a/heyoka/CMakeLists.txt
+++ b/heyoka/CMakeLists.txt
@@ -21,6 +21,9 @@ set(HEYOKA_PY_PYTHON_FILES
     _test_model.py
     _test_expression.py
     _test_dtens.py
+    _test_scalar_integrator.py
+    _test_batch_integrator.py
+    _test_ensemble.py
     model/__init__.py
 )
 
@@ -52,6 +55,7 @@ set(_HEYOKA_PY_CORE_SOURCES
     expose_batch_integrators.cpp
     numpy_memory.cpp
     expose_models.cpp
+    step_cb_wrapper.cpp
 )
 
 Python3_add_library(core MODULE WITH_SOABI ${_HEYOKA_PY_CORE_SOURCES})
diff --git a/heyoka/_ensemble_impl.py b/heyoka/_ensemble_impl.py
index e68db364..d152f2ff 100644
--- a/heyoka/_ensemble_impl.py
+++ b/heyoka/_ensemble_impl.py
@@ -22,11 +22,30 @@ def _splat_grid(arg, ta):
 # Thread-based implementation.
 def _ensemble_propagate_thread(tp, ta, arg, n_iter, gen, **kwargs):
     from concurrent.futures import ThreadPoolExecutor
-    from copy import deepcopy
+    from copy import deepcopy, copy
 
     # Pop the multithreading options from kwargs.
     max_workers = kwargs.pop("max_workers", None)
 
+    # Make deep copies of the callback argument, if present.
+    if "callback" in kwargs:
+        kwargs_list = []
+
+        for i in range(n_iter):
+            # Make a shallow copy of the original kwargs.
+            # new_kwargs will be a new dict containing
+            # references to the objects stored in kwargs.
+            new_kwargs = copy(kwargs)
+
+            # Update the callback argument in new_kwargs
+            # with a deep copy of the original callback object in
+            # kwargs.
+            new_kwargs.update(callback=deepcopy(kwargs["callback"]))
+
+            kwargs_list.append(new_kwargs)
+    else:
+        kwargs_list = [kwargs] * n_iter
+
     # The worker function.
     def func(i):
         # Create the local integrator.
@@ -34,11 +53,11 @@ def func(i):
 
         # Run the propagation.
         if tp == "until":
-            loc_ret = local_ta.propagate_until(arg, **kwargs)
+            loc_ret = local_ta.propagate_until(arg, **kwargs_list[i])
         elif tp == "for":
-            loc_ret = local_ta.propagate_for(arg, **kwargs)
+            loc_ret = local_ta.propagate_for(arg, **kwargs_list[i])
         else:
-            loc_ret = local_ta.propagate_grid(_splat_grid(arg, ta), **kwargs)
+            loc_ret = local_ta.propagate_grid(_splat_grid(arg, ta), **kwargs_list[i])
 
         # Return the results.
         # NOTE: in batch mode, loc_ret will be single
diff --git a/heyoka/_test_batch_integrator.py b/heyoka/_test_batch_integrator.py
new file mode 100644
index 00000000..83f7489d
--- /dev/null
+++ b/heyoka/_test_batch_integrator.py
@@ -0,0 +1,727 @@
+# Copyright 2020, 2021, 2022, 2023 Francesco Biscani (bluescarni@gmail.com), Dario Izzo (dario.izzo@gmail.com)
+#
+# This file is part of the heyoka.py library.
+#
+# This Source Code Form is subject to the terms of the Mozilla
+# Public License v. 2.0. If a copy of the MPL was not distributed
+# with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import unittest as _ut
+
+
+class batch_integrator_test_case(_ut.TestCase):
+    def test_type_conversions(self):
+        # Test to check automatic conversions of std::vector<T>
+        # in the integrator's constructor.
+
+        from . import taylor_adaptive_batch, make_vars, sin
+        import numpy as np
+
+        d_digs = np.finfo(np.double).nmant
+        ld_digs = np.finfo(np.longdouble).nmant
+
+        x, v = make_vars("x", "v")
+
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        ta = taylor_adaptive_batch(sys=sys, state=((0.0, 0.1), (0.25, 0.26)), tol=1e-4)
+        self.assertTrue(np.all(ta.state == ((0.0, 0.1), (0.25, 0.26))))
+
+        ta = taylor_adaptive_batch(
+            sys=sys, state=np.array([[0.0, 0.1], [0.25, 0.26]]), tol=1e-4
+        )
+        self.assertTrue(np.all(ta.state == ((0.0, 0.1), (0.25, 0.26))))
+
+        if d_digs == ld_digs:
+            return
+
+        ld = np.longdouble
+
+        # Check that conversion from other fp types is forbidden.
+        with self.assertRaises(TypeError) as cm:
+            ta = taylor_adaptive_batch(
+                sys=sys, state=((ld(0.0), ld(0.1)), (ld(0.25), ld(0.26))), tol=1e-4
+            )
+
+        with self.assertRaises(TypeError) as cm:
+            ta = taylor_adaptive_batch(
+                sys=sys, state=np.array([[0.0, 0.1], [0.25, 0.26]], dtype=ld), tol=1e-4
+            )
+
+    def test_copy(self):
+        from . import nt_event_batch, make_vars, sin, taylor_adaptive_batch
+        from copy import copy, deepcopy
+        import numpy as np
+
+        x, v = make_vars("x", "v")
+
+        # Use a pendulum for testing purposes.
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        def cb0(ta, t, d_sgn, bidx):
+            pass
+
+        ta = taylor_adaptive_batch(
+            sys=sys,
+            state=[[0, 0.01], [0.25, 0.26]],
+            nt_events=[nt_event_batch(v * v - 1e-10, cb0)],
+        )
+
+        ta.step()
+        ta.step()
+        ta.step()
+        ta.step()
+
+        class foo:
+            pass
+
+        ta.bar = foo()
+
+        self.assertEqual(id(ta.bar), id(copy(ta).bar))
+        self.assertNotEqual(id(ta.bar), id(deepcopy(ta).bar))
+        self.assertTrue(np.all(ta.state == copy(ta).state))
+        self.assertTrue(np.all(ta.state == deepcopy(ta).state))
+
+        ta_dc = deepcopy(ta)
+        self.assertEqual(ta_dc.state[0, 0], ta.state[0, 0])
+        ta.state[0, 0] += 1
+        self.assertNotEqual(ta_dc.state[0, 0], ta.state[0, 0])
+
+    def test_propagate_for(self):
+        from . import taylor_adaptive_batch, make_vars, sin
+        from copy import deepcopy
+        import numpy as np
+
+        ic = [[0.0, 0.1, 0.2, 0.3], [0.25, 0.26, 0.27, 0.28]]
+
+        x, v = make_vars("x", "v")
+
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        ta = taylor_adaptive_batch(sys=sys, state=ic)
+
+        # Compare vector/scalar delta_t and max_delta_t.
+        ta.propagate_for([10.0] * 4)
+        st = deepcopy(ta.state)
+        res = deepcopy(ta.propagate_res)
+
+        ta.set_time(0.0)
+        ta.state[:] = ic
+
+        ta.propagate_for(10.0)
+        self.assertTrue(np.all(ta.state == st))
+        self.assertEqual(res, ta.propagate_res)
+
+        ta.set_time(0.0)
+        ta.state[:] = ic
+
+        ta.propagate_for([10.0] * 4, max_delta_t=[1e-4] * 4)
+        st = deepcopy(ta.state)
+        res = deepcopy(ta.propagate_res)
+
+        ta.set_time(0.0)
+        ta.state[:] = ic
+
+        ta.propagate_for(10.0, max_delta_t=1e-4)
+        self.assertTrue(np.all(ta.state == st))
+        self.assertEqual(res, ta.propagate_res)
+
+        # Test that adding dynattrs to the integrator
+        # object via the propagate callback works.
+        def cb(ta):
+            if hasattr(ta, "counter"):
+                ta.counter += 1
+            else:
+                ta.counter = 0
+
+            return True
+
+        ta.propagate_for(10.0, callback=cb)
+
+        self.assertTrue(ta.counter > 0)
+
+        # Test that no copies of the callback are performed.
+        class cb:
+            def __call__(_, ta):
+                self.assertEqual(id(_), _.orig_id)
+
+                return True
+
+        cb_inst = cb()
+        cb_inst.orig_id = id(cb_inst)
+
+        ta.propagate_for(10.0, callback=cb_inst)
+
+        # Test with a non-callable callback.
+        with self.assertRaises(TypeError) as cm:
+            ta.set_time(0.0)
+            ta.state[:] = ic
+            ta.propagate_for(10.0, callback="hello world")
+        self.assertTrue(
+            "cannot be used as a step callback because it is not callable"
+            in str(cm.exception)
+        )
+
+        # Broken callback with wrong return type.
+        class broken_cb:
+            def __call__(self, ta):
+                return []
+
+        with self.assertRaises(TypeError) as cm:
+            ta.set_time(0.0)
+            ta.state[:] = ic
+            ta.propagate_for(10.0, callback=broken_cb())
+        self.assertTrue(
+            "The call operator of a step callback is expected to return a boolean, but a value of type"
+            in str(cm.exception)
+        )
+
+        # Callback with pre_hook().
+        class cb_hook:
+            def __call__(_, ta):
+                return True
+
+            def pre_hook(self, ta):
+                ta.foo = True
+
+        ta.set_time(0.0)
+        ta.state[:] = ic
+        ta.propagate_for(10.0, callback=cb_hook())
+        self.assertTrue(ta.foo)
+        delattr(ta, "foo")
+
+    def test_propagate_until(self):
+        from . import taylor_adaptive_batch, make_vars, sin
+        from copy import deepcopy
+        import numpy as np
+
+        ic = [[0.0, 0.1, 0.2, 0.3], [0.25, 0.26, 0.27, 0.28]]
+
+        x, v = make_vars("x", "v")
+
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        ta = taylor_adaptive_batch(sys=sys, state=ic)
+
+        # Compare vector/scalar delta_t and max_delta_t.
+        ta.propagate_until([10.0] * 4)
+        st = deepcopy(ta.state)
+        res = deepcopy(ta.propagate_res)
+
+        ta.set_time(0.0)
+        ta.state[:] = ic
+
+        ta.propagate_until(10.0)
+        self.assertTrue(np.all(ta.state == st))
+        self.assertEqual(res, ta.propagate_res)
+
+        ta.set_time(0.0)
+        ta.state[:] = ic
+
+        ta.propagate_until([10.0] * 4, max_delta_t=[1e-4] * 4)
+        st = deepcopy(ta.state)
+        res = deepcopy(ta.propagate_res)
+
+        ta.set_time(0.0)
+        ta.state[:] = ic
+
+        ta.propagate_until(10.0, max_delta_t=1e-4)
+        self.assertTrue(np.all(ta.state == st))
+        self.assertEqual(res, ta.propagate_res)
+
+        # Test that adding dynattrs to the integrator
+        # object via the propagate callback works.
+        def cb(ta):
+            if hasattr(ta, "counter"):
+                ta.counter += 1
+            else:
+                ta.counter = 0
+
+            return True
+
+        ta.propagate_until(20.0, callback=cb)
+
+        self.assertTrue(ta.counter > 0)
+
+        # Test that no copies of the callback are performed.
+        class cb:
+            def __call__(_, ta):
+                self.assertEqual(id(_), _.orig_id)
+
+                return True
+
+        cb_inst = cb()
+        cb_inst.orig_id = id(cb_inst)
+
+        ta.propagate_until(30.0, callback=cb_inst)
+
+        # Test with a non-callable callback.
+        with self.assertRaises(TypeError) as cm:
+            ta.set_time(0.0)
+            ta.state[:] = ic
+            ta.propagate_until(10.0, callback="hello world")
+        self.assertTrue(
+            "cannot be used as a step callback because it is not callable"
+            in str(cm.exception)
+        )
+
+        # Broken callback with wrong return type.
+        class broken_cb:
+            def __call__(self, ta):
+                return []
+
+        with self.assertRaises(TypeError) as cm:
+            ta.set_time(0.0)
+            ta.state[:] = ic
+            ta.propagate_until(10.0, callback=broken_cb())
+        self.assertTrue(
+            "The call operator of a step callback is expected to return a boolean, but a value of type"
+            in str(cm.exception)
+        )
+
+        # Callback with pre_hook().
+        class cb_hook:
+            def __call__(_, ta):
+                return True
+
+            def pre_hook(self, ta):
+                ta.foo = True
+
+        ta.set_time(0.0)
+        ta.state[:] = ic
+        ta.propagate_until(10.0, callback=cb_hook())
+        self.assertTrue(ta.foo)
+        delattr(ta, "foo")
+
+    def test_update_d_output(self):
+        from . import taylor_adaptive_batch, make_vars, sin
+        from sys import getrefcount
+        from copy import deepcopy
+        import numpy as np
+
+        x, v = make_vars("x", "v")
+
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        ta = taylor_adaptive_batch(
+            sys=sys, state=[[0.0, 0.1, 0.2, 0.3], [0.25, 0.26, 0.27, 0.28]]
+        )
+
+        ta.step(write_tc=True)
+
+        # Scalar overload.
+        with self.assertRaises(ValueError) as cm:
+            ta.update_d_output(0.3)[0] = 0.5
+
+        d_out = ta.update_d_output(0.3)
+        self.assertEqual(d_out.shape, (2, 4))
+        rc = getrefcount(ta)
+        tmp_out = ta.update_d_output(0.2)
+        new_rc = getrefcount(ta)
+        self.assertEqual(new_rc, rc + 1)
+
+        # Vector overload.
+        with self.assertRaises(ValueError) as cm:
+            ta.update_d_output([0.3, 0.4, 0.45, 0.46])[0] = 0.5
+
+        d_out2 = ta.update_d_output([0.3, 0.4, 0.45, 0.46])
+        self.assertEqual(d_out2.shape, (2, 4))
+        rc = getrefcount(ta)
+        tmp_out2 = ta.update_d_output([0.31, 0.41, 0.66, 0.67])
+        new_rc = getrefcount(ta)
+        self.assertEqual(new_rc, rc + 1)
+
+        cp = deepcopy(ta.update_d_output(0.3))
+        self.assertTrue(np.all(cp == ta.update_d_output([0.3] * 4)))
+
+        # Functional testing.
+        ta.set_time(0.0)
+        ta.state[:] = [[0.0, 0.01, 0.02, 0.03], [0.205, 0.206, 0.207, 0.208]]
+        ta.step(write_tc=True)
+        ta.update_d_output(ta.time)
+        self.assertTrue(
+            np.allclose(
+                ta.d_output,
+                ta.state,
+                rtol=np.finfo(float).eps * 10,
+                atol=np.finfo(float).eps * 10,
+            )
+        )
+        ta.update_d_output(0.0, rel_time=True)
+        self.assertTrue(
+            np.allclose(
+                ta.d_output,
+                ta.state,
+                rtol=np.finfo(float).eps * 10,
+                atol=np.finfo(float).eps * 10,
+            )
+        )
+
+    def test_set_time(self):
+        from . import taylor_adaptive_batch, make_vars, sin
+        import numpy as np
+
+        x, v = make_vars("x", "v")
+
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        ta = taylor_adaptive_batch(sys=sys, state=[[0.0, 0.1], [0.25, 0.26]])
+
+        self.assertTrue(np.all(ta.time == [0, 0]))
+
+        ta.set_time([-1.0, 1.0])
+        self.assertTrue(np.all(ta.time == [-1, 1]))
+
+        ta.set_time(5.0)
+        self.assertTrue(np.all(ta.time == [5, 5]))
+
+    def test_dtime(self):
+        from . import taylor_adaptive_batch, make_vars, sin
+        import numpy as np
+
+        x, v = make_vars("x", "v")
+
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        ta = taylor_adaptive_batch(sys=sys, state=[[0.0, 0.1], [0.25, 0.26]])
+
+        self.assertTrue(np.all(ta.dtime[0] == [0, 0]))
+        self.assertTrue(np.all(ta.dtime[1] == [0, 0]))
+
+        # Check not writeable,
+        with self.assertRaises(ValueError) as cm:
+            ta.dtime[0][0] = 0.5
+
+        with self.assertRaises(ValueError) as cm:
+            ta.dtime[1][0] = 0.5
+
+        ta.step()
+        ta.propagate_for(1000.1)
+
+        self.assertFalse(np.all(ta.dtime[1] == [0, 0]))
+
+        ta.set_dtime(1.0, 0.5)
+
+        self.assertTrue(np.all(ta.dtime[0] == [1.5, 1.5]))
+        self.assertTrue(np.all(ta.dtime[1] == [0, 0]))
+
+        ta.set_dtime([1.0, 2.0], [0.5, 0.25])
+
+        self.assertTrue(np.all(ta.dtime[0] == [1.5, 2.25]))
+        self.assertTrue(np.all(ta.dtime[1] == [0, 0]))
+
+        # Failure modes.
+        with self.assertRaises(TypeError) as cm:
+            ta.set_dtime([1.0, 2.0], 0.5)
+        self.assertTrue(
+            "The two arguments to the set_dtime() method must be of the same type"
+            in str(cm.exception)
+        )
+
+    def test_basic(self):
+        from . import taylor_adaptive_batch, make_vars, t_event_batch, sin
+
+        x, v = make_vars("x", "v")
+
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        ta = taylor_adaptive_batch(
+            sys=sys, state=[[0.0, 0.1], [0.25, 0.26]], t_events=[t_event_batch(v)]
+        )
+
+        self.assertTrue(ta.with_events)
+        self.assertFalse(ta.compact_mode)
+        self.assertFalse(ta.high_accuracy)
+        self.assertEqual(ta.state_vars, [x, v])
+        self.assertEqual(ta.rhs, [v, -9.8 * sin(x)])
+
+        ta = taylor_adaptive_batch(
+            sys=sys,
+            state=[[0.0, 0.1], [0.25, 0.26]],
+            compact_mode=True,
+            high_accuracy=True,
+        )
+
+        self.assertFalse(ta.with_events)
+        self.assertTrue(ta.compact_mode)
+        self.assertTrue(ta.high_accuracy)
+        self.assertFalse(ta.llvm_state.fast_math)
+        self.assertFalse(ta.llvm_state.force_avx512)
+        self.assertEqual(ta.llvm_state.opt_level, 3)
+
+        # Test the custom llvm_state flags.
+        ta = taylor_adaptive_batch(
+            sys=sys,
+            state=[[0.0, 0.1], [0.25, 0.26]],
+            compact_mode=True,
+            high_accuracy=True,
+            force_avx512=True,
+            fast_math=True,
+            opt_level=0,
+        )
+
+        self.assertTrue(ta.llvm_state.fast_math)
+        self.assertTrue(ta.llvm_state.force_avx512)
+        self.assertEqual(ta.llvm_state.opt_level, 0)
+
+    def test_events(self):
+        from . import (
+            nt_event_batch,
+            t_event_batch,
+            make_vars,
+            sin,
+            taylor_adaptive_batch,
+        )
+
+        x, v = make_vars("x", "v")
+
+        # Use a pendulum for testing purposes.
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        def cb0(ta, t, d_sgn, bidx):
+            pass
+
+        ta = taylor_adaptive_batch(
+            sys=sys,
+            state=[[0.0, 0.001], [0.25, 0.2501]],
+            nt_events=[nt_event_batch(v * v - 1e-10, cb0)],
+            t_events=[t_event_batch(v)],
+        )
+
+        self.assertTrue(ta.with_events)
+        self.assertEqual(len(ta.t_events), 1)
+        self.assertEqual(len(ta.nt_events), 1)
+
+        ta.propagate_until([1e9, 1e9])
+        self.assertTrue(all(int(_[0]) == -1 for _ in ta.propagate_res))
+
+        self.assertFalse(ta.te_cooldowns[0][0] is None)
+        self.assertFalse(ta.te_cooldowns[1][0] is None)
+
+        ta.reset_cooldowns(0)
+        self.assertTrue(ta.te_cooldowns[0][0] is None)
+        self.assertFalse(ta.te_cooldowns[1][0] is None)
+
+        ta.reset_cooldowns()
+        self.assertTrue(ta.te_cooldowns[0][0] is None)
+        self.assertTrue(ta.te_cooldowns[1][0] is None)
+
+    def test_s11n(self):
+        from . import (
+            nt_event_batch,
+            t_event_batch,
+            make_vars,
+            sin,
+            taylor_adaptive_batch,
+        )
+        import numpy as np
+        import pickle
+
+        x, v = make_vars("x", "v")
+
+        # Use a pendulum for testing purposes.
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        def cb0(ta, t, d_sgn, bidx):
+            pass
+
+        ta = taylor_adaptive_batch(
+            sys=sys,
+            state=[[0, 0.01], [0.25, 0.26]],
+            nt_events=[nt_event_batch(v * v - 1e-10, cb0)],
+        )
+
+        ta.step()
+        ta.step()
+        ta.step()
+        ta.step()
+
+        ta2 = pickle.loads(pickle.dumps(ta))
+
+        self.assertTrue(np.all(ta.state == ta2.state))
+        self.assertTrue(np.all(ta.time == ta2.time))
+
+        self.assertEqual(len(ta.t_events), len(ta2.t_events))
+        self.assertEqual(len(ta.nt_events), len(ta2.nt_events))
+
+        ta.step()
+        ta2.step()
+
+        self.assertTrue(np.all(ta.state == ta2.state))
+        self.assertTrue(np.all(ta.time == ta2.time))
+
+        ta = taylor_adaptive_batch(sys=sys, state=[[0, 0.01], [0.25, 0.26]], tol=1e-6)
+
+        self.assertEqual(ta.tol, 1e-6)
+
+        # Test dynamic attributes.
+        ta.foo = "hello world"
+        ta = pickle.loads(pickle.dumps(ta))
+        self.assertEqual(ta.foo, "hello world")
+
+        # Try also an integrator with stateful event callback.
+        class cb1:
+            def __init__(self):
+                self.n = 0
+
+            def __call__(self, ta, bool, d_sgn, bidx):
+                self.n = self.n + 1
+
+                return True
+
+        clb = cb1()
+        ta = taylor_adaptive_batch(
+            sys=sys,
+            state=[[0, 0.01], [0.25, 0.26]],
+            t_events=[t_event_batch(v, callback=clb)],
+        )
+
+        self.assertNotEqual(id(clb), id(ta.t_events[0].callback))
+
+        self.assertEqual(ta.t_events[0].callback.n, 0)
+
+        ta.propagate_until([100.0, 100.0])
+
+        ta2 = pickle.loads(pickle.dumps(ta))
+
+        self.assertEqual(ta.t_events[0].callback.n, ta2.t_events[0].callback.n)
+
+    def test_propagate_grid(self):
+        from . import make_vars, taylor_adaptive, taylor_adaptive_batch, sin
+        import numpy as np
+        from copy import deepcopy
+
+        x, v = make_vars("x", "v")
+        eqns = [(x, v), (v, -9.8 * sin(x))]
+
+        x_ic = [0.06, 0.07, 0.08, 0.09]
+        v_ic = [0.025, 0.026, 0.027, 0.028]
+
+        ta = taylor_adaptive_batch(eqns, [x_ic, v_ic])
+
+        # Failure modes.
+        with self.assertRaises(ValueError) as cm:
+            ta.propagate_grid([])
+        self.assertTrue(
+            "Invalid grid passed to the propagate_grid() method of a batch integrator: "
+            "the expected number of dimensions is 2, but the input array has a dimension of 1"
+            in str(cm.exception)
+        )
+
+        with self.assertRaises(ValueError) as cm:
+            ta.propagate_grid([[1, 2], [3, 4]])
+        self.assertTrue(
+            "Invalid grid passed to the propagate_grid() method of a batch integrator: "
+            "the shape must be (n, 4) but the number of columns is 2 instead"
+            in str(cm.exception)
+        )
+
+        # Run a simple scalar/batch comparison.
+        tas = []
+
+        for x0, v0 in zip(x_ic, v_ic):
+            tas.append(taylor_adaptive(eqns, [x0, v0]))
+
+        grid = np.array(
+            [
+                [-0.1, -0.2, -0.3, -0.4],
+                [0.01, 0.02, 0.03, 0.9],
+                [1.0, 1.1, 1.2, 1.3],
+                [11.0, 11.1, 11.2, 11.3],
+            ]
+        )
+
+        bres = ta.propagate_grid(grid)
+
+        sres = [
+            tas[0].propagate_grid(grid[:, 0]),
+            tas[1].propagate_grid(grid[:, 1]),
+            tas[2].propagate_grid(grid[:, 2]),
+            tas[3].propagate_grid(grid[:, 3]),
+        ]
+
+        self.assertTrue(np.max(np.abs(sres[0][4] - bres[:, :, 0]).flatten()) < 1e-14)
+        self.assertTrue(np.max(np.abs(sres[1][4] - bres[:, :, 1]).flatten()) < 1e-14)
+        self.assertTrue(np.max(np.abs(sres[2][4] - bres[:, :, 2]).flatten()) < 1e-14)
+        self.assertTrue(np.max(np.abs(sres[3][4] - bres[:, :, 3]).flatten()) < 1e-14)
+
+        # Test vector/scalar max_delta_t.
+        ta.set_time(0.0)
+        ta.state[:] = [x_ic, v_ic]
+
+        bres = ta.propagate_grid(grid, max_delta_t=[1e-3] * 4)
+        res = deepcopy(ta.propagate_res)
+
+        ta.set_time(0.0)
+        ta.state[:] = [x_ic, v_ic]
+
+        bres2 = ta.propagate_grid(grid, max_delta_t=1e-3)
+
+        self.assertTrue(np.all(bres == bres2))
+        self.assertEqual(ta.propagate_res, res)
+
+        # Test that adding dynattrs to the integrator
+        # object via the propagate callback works.
+        def cb(ta):
+            if hasattr(ta, "counter"):
+                ta.counter += 1
+            else:
+                ta.counter = 0
+
+            return True
+
+        ta.set_time(0.0)
+        ta.propagate_grid(grid, callback=cb)
+
+        self.assertTrue(ta.counter > 0)
+
+        # Test that no copies of the callback are performed.
+        class cb:
+            def __call__(_, ta):
+                self.assertEqual(id(_), _.orig_id)
+
+                return True
+
+        cb_inst = cb()
+        cb_inst.orig_id = id(cb_inst)
+
+        ta.set_time(0.0)
+        ta.propagate_grid(grid, callback=cb_inst)
+
+        # Test with a non-callable callback.
+        with self.assertRaises(TypeError) as cm:
+            ta.set_time(0.0)
+            ta.state[:] = [x_ic, v_ic]
+            ta.propagate_grid(grid, callback="hello world")
+        self.assertTrue(
+            "cannot be used as a step callback because it is not callable"
+            in str(cm.exception)
+        )
+
+        # Broken callback with wrong return type.
+        class broken_cb:
+            def __call__(self, ta):
+                return []
+
+        with self.assertRaises(TypeError) as cm:
+            ta.set_time(0.0)
+            ta.state[:] = [x_ic, v_ic]
+            ta.propagate_grid(grid, callback=broken_cb())
+        self.assertTrue(
+            "The call operator of a step callback is expected to return a boolean, but a value of type"
+            in str(cm.exception)
+        )
+
+        # Callback with pre_hook().
+        class cb_hook:
+            def __call__(_, ta):
+                return True
+
+            def pre_hook(self, ta):
+                ta.foo = True
+
+        ta.set_time(0.0)
+        ta.state[:] = [x_ic, v_ic]
+        ta.propagate_grid(grid, callback=cb_hook())
+        self.assertTrue(ta.foo)
+        delattr(ta, "foo")
diff --git a/heyoka/_test_ensemble.py b/heyoka/_test_ensemble.py
new file mode 100644
index 00000000..67fe6073
--- /dev/null
+++ b/heyoka/_test_ensemble.py
@@ -0,0 +1,400 @@
+# Copyright 2020, 2021, 2022, 2023 Francesco Biscani (bluescarni@gmail.com), Dario Izzo (dario.izzo@gmail.com)
+#
+# This file is part of the heyoka.py library.
+#
+# This Source Code Form is subject to the terms of the Mozilla
+# Public License v. 2.0. If a copy of the MPL was not distributed
+# with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import unittest as _ut
+
+
+class ensemble_test_case(_ut.TestCase):
+    def test_batch(self):
+        from . import (
+            ensemble_propagate_until_batch,
+            ensemble_propagate_for_batch,
+            ensemble_propagate_grid_batch,
+            make_vars,
+            sin,
+            taylor_adaptive_batch,
+        )
+        import numpy as np
+
+        x, v = make_vars("x", "v")
+
+        # Use a pendulum for testing purposes.
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        algos = ["thread", "process"]
+
+        ta = taylor_adaptive_batch(sys=sys, state=[[0.0] * 4] * 2)
+
+        ics = np.zeros((10, 2, 4))
+        for i in range(10):
+            ics[i, 0] = [
+                0.05 + i / 100,
+                0.051 + i / 100,
+                0.052 + i / 100,
+                0.053 + i / 100.0,
+            ]
+            ics[i, 0] = [
+                0.025 + i / 100,
+                0.026 + i / 100,
+                0.027 + i / 100,
+                0.028 + i / 100.0,
+            ]
+
+        # propagate_until().
+        def gen(ta, idx):
+            ta.set_time(0.0)
+            ta.state[:] = ics[idx]
+
+            return ta
+
+        for algo in algos:
+            if algo == "thread":
+                ret = ensemble_propagate_until_batch(
+                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8
+                )
+            elif algo == "process":
+                ret = ensemble_propagate_until_batch(
+                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, chunksize=3
+                )
+
+            self.assertEqual(len(ret), 10)
+
+            for i in range(10):
+                ta.set_time(0.0)
+                ta.state[:] = ics[i]
+                loc_ret = ta.propagate_until(20.0)
+
+                for j in range(4):
+                    self.assertAlmostEqual(ret[i][0].time[j], 20.0)
+                self.assertTrue(np.all(ta.state == ret[i][0].state))
+                self.assertTrue(ret[i][1] is None)
+                self.assertTrue(np.all(ta.time == ret[i][0].time))
+                self.assertEqual(ta.propagate_res, ret[i][0].propagate_res)
+
+            # Run a test with c_output too.
+            if algo == "thread":
+                ret = ensemble_propagate_until_batch(
+                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, c_output=True
+                )
+            elif algo == "process":
+                ret = ensemble_propagate_until_batch(
+                    ta,
+                    20.0,
+                    10,
+                    gen,
+                    algorithm=algo,
+                    max_workers=8,
+                    chunksize=3,
+                    c_output=True,
+                )
+
+            self.assertEqual(len(ret), 10)
+
+            for i in range(10):
+                ta.set_time(0.0)
+                ta.state[:] = ics[i]
+                loc_ret = ta.propagate_until(20.0, c_output=True)
+
+                for j in range(4):
+                    self.assertAlmostEqual(ret[i][0].time[j], 20.0)
+                self.assertTrue(np.all(ta.state == ret[i][0].state))
+                self.assertFalse(ret[i][1] is None)
+                self.assertTrue(np.all(ta.time == ret[i][0].time))
+                self.assertEqual(ta.propagate_res, ret[i][0].propagate_res)
+
+                self.assertTrue(np.all(loc_ret(5.0) == ret[i][1](5.0)))
+
+        # propagate_for().
+        def gen(ta, idx):
+            ta.set_time(10.0)
+            ta.state[:] = ics[idx]
+
+            return ta
+
+        for algo in algos:
+            if algo == "thread":
+                ret = ensemble_propagate_for_batch(
+                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8
+                )
+            elif algo == "process":
+                ret = ensemble_propagate_for_batch(
+                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, chunksize=3
+                )
+
+            self.assertEqual(len(ret), 10)
+
+            for i in range(10):
+                ta.set_time(10.0)
+                ta.state[:] = ics[i]
+                loc_ret = ta.propagate_for(20.0)
+
+                for j in range(4):
+                    self.assertAlmostEqual(ret[i][0].time[j], 30.0)
+                self.assertTrue(np.all(ta.state == ret[i][0].state))
+                self.assertTrue(ret[i][1] is None)
+                self.assertTrue(np.all(ta.time == ret[i][0].time))
+                self.assertEqual(ta.propagate_res, ret[i][0].propagate_res)
+
+        # propagate_grid().
+        grid = np.linspace(0.0, 20.0, 80)
+
+        splat_grid = np.repeat(grid, 4).reshape(-1, 4)
+
+        def gen(ta, idx):
+            ta.set_time(0.0)
+            ta.state[:] = ics[idx]
+
+            return ta
+
+        for algo in algos:
+            if algo == "thread":
+                ret = ensemble_propagate_grid_batch(
+                    ta, grid, 10, gen, algorithm=algo, max_workers=8
+                )
+            elif algo == "process":
+                ret = ensemble_propagate_grid_batch(
+                    ta, grid, 10, gen, algorithm=algo, max_workers=8, chunksize=3
+                )
+
+            self.assertEqual(len(ret), 10)
+
+            for i in range(10):
+                ta.set_time(0.0)
+                ta.state[:] = ics[i]
+                loc_ret = ta.propagate_grid(splat_grid)
+
+                self.assertTrue(np.all(loc_ret == ret[i][1]))
+
+                for j in range(4):
+                    self.assertAlmostEqual(ret[i][0].time[j], 20.0)
+                self.assertTrue(np.all(ta.state == ret[i][0].state))
+                self.assertTrue(np.all(ta.time == ret[i][0].time))
+                self.assertEqual(ta.propagate_res, ret[i][0].propagate_res)
+
+    def test_scalar(self):
+        from . import (
+            ensemble_propagate_until,
+            ensemble_propagate_for,
+            ensemble_propagate_grid,
+            make_vars,
+            sin,
+            taylor_adaptive,
+            taylor_outcome,
+        )
+        import numpy as np
+
+        x, v = make_vars("x", "v")
+
+        # Use a pendulum for testing purposes.
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        algos = ["thread", "process"]
+
+        ta = taylor_adaptive(sys=sys, state=[0.0] * 2)
+
+        ics = np.array([[0.05, 0.025]] * 10)
+        for i in range(10):
+            ics[i] += i / 100.0
+
+        # propagate_until().
+        def gen(ta, idx):
+            ta.time = 0.0
+            ta.state[:] = ics[idx]
+
+            return ta
+
+        for algo in algos:
+            if algo == "thread":
+                ret = ensemble_propagate_until(
+                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8
+                )
+            elif algo == "process":
+                ret = ensemble_propagate_until(
+                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, chunksize=3
+                )
+
+            self.assertEqual(len(ret), 10)
+
+            self.assertTrue(all([_[1] == taylor_outcome.time_limit for _ in ret]))
+
+            for i in range(10):
+                ta.time = 0.0
+                ta.state[:] = ics[i]
+                loc_ret = ta.propagate_until(20.0)
+
+                self.assertAlmostEqual(ret[i][0].time, 20.0)
+                self.assertTrue(np.all(ta.state == ret[i][0].state))
+                self.assertEqual(loc_ret, ret[i][1:])
+                self.assertEqual(ta.time, ret[i][0].time)
+
+            # Run a test with c_output too.
+            if algo == "thread":
+                ret = ensemble_propagate_until(
+                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, c_output=True
+                )
+            elif algo == "process":
+                ret = ensemble_propagate_until(
+                    ta,
+                    20.0,
+                    10,
+                    gen,
+                    algorithm=algo,
+                    max_workers=8,
+                    chunksize=3,
+                    c_output=True,
+                )
+
+            self.assertEqual(len(ret), 10)
+
+            self.assertTrue(all([_[1] == taylor_outcome.time_limit for _ in ret]))
+
+            for i in range(10):
+                ta.time = 0.0
+                ta.state[:] = ics[i]
+                loc_ret = ta.propagate_until(20.0, c_output=True)
+
+                self.assertAlmostEqual(ret[i][0].time, 20.0)
+                self.assertTrue(np.all(ta.state == ret[i][0].state))
+                self.assertEqual(loc_ret[:-1], ret[i][1:-1])
+                self.assertEqual(ta.time, ret[i][0].time)
+
+                self.assertTrue(np.all(loc_ret[-1](5.0) == ret[i][-1](5.0)))
+
+        # propagate_for().
+        def gen(ta, idx):
+            ta.time = 10.0
+            ta.state[:] = ics[idx]
+
+            return ta
+
+        for algo in algos:
+            if algo == "thread":
+                ret = ensemble_propagate_for(
+                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8
+                )
+            elif algo == "process":
+                ret = ensemble_propagate_for(
+                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, chunksize=3
+                )
+
+            self.assertEqual(len(ret), 10)
+
+            self.assertTrue(all([_[1] == taylor_outcome.time_limit for _ in ret]))
+
+            for i in range(10):
+                ta.time = 10.0
+                ta.state[:] = ics[i]
+                loc_ret = ta.propagate_for(20.0)
+
+                self.assertAlmostEqual(ret[i][0].time, 30.0)
+                self.assertTrue(np.all(ta.state == ret[i][0].state))
+                self.assertEqual(loc_ret, ret[i][1:])
+                self.assertEqual(ta.time, ret[i][0].time)
+
+        # propagate_grid().
+        grid = np.linspace(0.0, 20.0, 80)
+
+        def gen(ta, idx):
+            ta.time = 0.0
+            ta.state[:] = ics[idx]
+
+            return ta
+
+        for algo in algos:
+            if algo == "thread":
+                ret = ensemble_propagate_grid(
+                    ta, grid, 10, gen, algorithm=algo, max_workers=8
+                )
+            elif algo == "process":
+                ret = ensemble_propagate_grid(
+                    ta, grid, 10, gen, algorithm=algo, max_workers=8, chunksize=3
+                )
+
+            self.assertEqual(len(ret), 10)
+
+            self.assertTrue(all([_[1] == taylor_outcome.time_limit for _ in ret]))
+
+            for i in range(10):
+                ta.time = 0.0
+                ta.state[:] = ics[i]
+                loc_ret = ta.propagate_grid(grid)
+
+                self.assertAlmostEqual(ret[i][0].time, 20.0)
+                self.assertTrue(np.all(ta.state == ret[i][0].state))
+                self.assertEqual(loc_ret[:-1], ret[i][1:-1])
+                self.assertTrue(np.all(loc_ret[-1] == ret[i][-1]))
+                self.assertEqual(ta.time, ret[i][0].time)
+
+        # Error handling.
+        with self.assertRaises(TypeError) as cm:
+            ensemble_propagate_until(ta, 20.0, "a", gen)
+        self.assertTrue(
+            "The n_iter parameter must be an integer, but an object of type"
+            in str(cm.exception)
+        )
+
+        with self.assertRaises(ValueError) as cm:
+            ensemble_propagate_until(ta, 20.0, -1, gen)
+        self.assertTrue(
+            "The n_iter parameter must be non-negative" in str(cm.exception)
+        )
+
+        with self.assertRaises(TypeError) as cm:
+            ensemble_propagate_until(ta, [20.0], 10, gen)
+        self.assertTrue(
+            "Cannot perform an ensemble propagate_until/for(): the final epoch/time interval must be a scalar, not an iterable object"
+            in str(cm.exception)
+        )
+
+        with self.assertRaises(TypeError) as cm:
+            ensemble_propagate_for(ta, [20.0], 10, gen)
+        self.assertTrue(
+            "Cannot perform an ensemble propagate_until/for(): the final epoch/time interval must be a scalar, not an iterable object"
+            in str(cm.exception)
+        )
+
+        with self.assertRaises(ValueError) as cm:
+            ensemble_propagate_grid(ta, [[20.0, 20.0]], 10, gen)
+        self.assertTrue(
+            "Cannot perform an ensemble propagate_grid(): the input time grid must be one-dimensional, but instead it has 2 dimensions"
+            in str(cm.exception)
+        )
+
+        with self.assertRaises(TypeError) as cm:
+            ensemble_propagate_until(ta, 20.0, 10, gen, max_delta_t=[10])
+        self.assertTrue(
+            'Cannot perform an ensemble propagate_until/for/grid(): the "max_delta_t" argument must be a scalar, not an iterable object'
+            in str(cm.exception)
+        )
+
+        # NOTE: check that the chunksize option is not recognised
+        # in threaded mode.
+        with self.assertRaises(TypeError) as cm:
+            ensemble_propagate_until(ta, 20.0, 10, gen, chunksize=1)
+
+        # Check that callbacks are deep-copied in thread-based
+        # ensemble propagations.
+
+        class step_cb:
+            def __call__(_, ta):
+                self.assertNotEqual(id(_), _.orig_id)
+
+                return True
+
+        cb = step_cb()
+        cb.orig_id = id(cb)
+
+        def gen(ta, idx):
+            ta.time = 0.0
+            ta.state[:] = ics[idx]
+
+            return ta
+
+        ensemble_propagate_until(
+            ta, 20.0, 10, gen, algorithm="thread", max_workers=8, callback=cb
+        )
diff --git a/heyoka/_test_scalar_integrator.py b/heyoka/_test_scalar_integrator.py
new file mode 100644
index 00000000..70c81c03
--- /dev/null
+++ b/heyoka/_test_scalar_integrator.py
@@ -0,0 +1,357 @@
+# Copyright 2020, 2021, 2022, 2023 Francesco Biscani (bluescarni@gmail.com), Dario Izzo (dario.izzo@gmail.com)
+#
+# This file is part of the heyoka.py library.
+#
+# This Source Code Form is subject to the terms of the Mozilla
+# Public License v. 2.0. If a copy of the MPL was not distributed
+# with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import unittest as _ut
+
+
+class scalar_integrator_test_case(_ut.TestCase):
+    def test_type_conversions(self):
+        # Test to check automatic conversions of std::vector<T>
+        # in the integrator's constructor.
+
+        from . import taylor_adaptive, make_vars, sin
+        import numpy as np
+
+        d_digs = np.finfo(np.double).nmant
+        ld_digs = np.finfo(np.longdouble).nmant
+
+        x, v = make_vars("x", "v")
+
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        ta = taylor_adaptive(sys=sys, state=(0.0, 0.25), tol=1e-4)
+        self.assertTrue(np.all(ta.state == [0.0, 0.25]))
+        ta = taylor_adaptive(sys=sys, state=np.array([0.0, 0.25]), tol=1e-4)
+        self.assertTrue(np.all(ta.state == [0.0, 0.25]))
+
+        if d_digs == ld_digs:
+            return
+
+        # Check that conversion from other fp types is forbidden.
+        with self.assertRaises(TypeError) as cm:
+            ta = taylor_adaptive(
+                sys=sys, state=(np.longdouble(0.0), np.longdouble(0.25)), tol=1e-4
+            )
+
+        with self.assertRaises(TypeError) as cm:
+            ta = taylor_adaptive(
+                sys=sys, state=np.array([0.0, 0.25], dtype=np.longdouble), tol=1e-4
+            )
+
+    def test_dtime(self):
+        from . import taylor_adaptive, make_vars, sin
+
+        x, v = make_vars("x", "v")
+
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        ta = taylor_adaptive(sys=sys, state=[0.0, 0.25])
+
+        self.assertEqual(ta.dtime, (0.0, 0.0))
+
+        ta.step()
+        ta.propagate_for(1001.1)
+
+        self.assertTrue(ta.dtime[1] != 0)
+
+        ta.dtime = (1, 0.5)
+
+        self.assertEqual(ta.dtime, (1.5, 0.0))
+
+    def test_copy(self):
+        from . import taylor_adaptive, make_vars, t_event, sin
+        import numpy as np
+        from copy import copy, deepcopy
+
+        x, v = make_vars("x", "v")
+
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        ta = taylor_adaptive(sys=sys, state=[0.0, 0.25], t_events=[t_event(v)])
+
+        ta.step()
+
+        class foo:
+            pass
+
+        ta.bar = foo()
+
+        self.assertEqual(id(ta.bar), id(copy(ta).bar))
+        self.assertNotEqual(id(ta.bar), id(deepcopy(ta).bar))
+        self.assertTrue(np.all(ta.state == copy(ta).state))
+        self.assertTrue(np.all(ta.state == deepcopy(ta).state))
+
+        ta_dc = deepcopy(ta)
+        self.assertEqual(ta_dc.state[0], ta.state[0])
+        ta.state[0] += 1
+        self.assertNotEqual(ta_dc.state[0], ta.state[0])
+
+    def test_basic(self):
+        from . import taylor_adaptive, make_vars, t_event, sin
+
+        x, v = make_vars("x", "v")
+
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        ta = taylor_adaptive(sys=sys, state=[0.0, 0.25], t_events=[t_event(v)])
+
+        self.assertTrue(ta.with_events)
+        self.assertFalse(ta.compact_mode)
+        self.assertFalse(ta.high_accuracy)
+        self.assertEqual(ta.state_vars, [x, v])
+        self.assertEqual(ta.rhs, [v, -9.8 * sin(x)])
+
+        ta = taylor_adaptive(
+            sys=sys, state=[0.0, 0.25], compact_mode=True, high_accuracy=True
+        )
+
+        self.assertFalse(ta.with_events)
+        self.assertTrue(ta.compact_mode)
+        self.assertTrue(ta.high_accuracy)
+        self.assertFalse(ta.llvm_state.fast_math)
+        self.assertFalse(ta.llvm_state.force_avx512)
+        self.assertEqual(ta.llvm_state.opt_level, 3)
+
+        # Check that certain properties are read-only
+        # arrays and the writeability cannot be changed.
+        self.assertFalse(ta.tc.flags.writeable)
+        with self.assertRaises(ValueError):
+            ta.tc.flags.writeable = True
+        self.assertFalse(ta.d_output.flags.writeable)
+        with self.assertRaises(ValueError):
+            ta.d_output.flags.writeable = True
+
+        # Test the custom llvm_state flags.
+        ta = taylor_adaptive(
+            sys=sys,
+            state=[0.0, 0.25],
+            compact_mode=True,
+            high_accuracy=True,
+            force_avx512=True,
+            fast_math=True,
+            opt_level=0,
+        )
+
+        self.assertTrue(ta.llvm_state.fast_math)
+        self.assertTrue(ta.llvm_state.force_avx512)
+        self.assertEqual(ta.llvm_state.opt_level, 0)
+
+        # Test that adding dynattrs to the integrator
+        # object via the propagate callback works.
+        def cb(ta):
+            if hasattr(ta, "counter"):
+                ta.counter += 1
+            else:
+                ta.counter = 0
+
+            return True
+
+        ta.propagate_until(10.0, callback=cb)
+
+        self.assertTrue(ta.counter > 0)
+        orig_ct = ta.counter
+
+        ta.propagate_for(10.0, callback=cb)
+
+        self.assertTrue(ta.counter > orig_ct)
+        orig_ct = ta.counter
+
+        ta.time = 0.0
+        ta.propagate_grid([0.0, 1.0, 2.0], callback=cb)
+
+        self.assertTrue(ta.counter > orig_ct)
+
+        # Test that no copies of the callback are performed.
+        class cb:
+            def __call__(_, ta):
+                self.assertEqual(id(_), _.orig_id)
+
+                return True
+
+        cb_inst = cb()
+        cb_inst.orig_id = id(cb_inst)
+
+        ta.time = 0.0
+        ta.propagate_until(10.0, callback=cb_inst)
+        ta.propagate_for(10.0, callback=cb_inst)
+        ta.time = 0.0
+        ta.propagate_grid([0.0, 1.0, 2.0], callback=cb_inst)
+
+        # Test with a non-callable callback.
+        with self.assertRaises(TypeError) as cm:
+            ta.time = 0.0
+            ta.propagate_grid([0.0, 1.0, 2.0], callback="hello world")
+        self.assertTrue(
+            "cannot be used as a step callback because it is not callable"
+            in str(cm.exception)
+        )
+
+        # Broken callback with wrong return type.
+        class broken_cb:
+            def __call__(self, ta):
+                return []
+
+        with self.assertRaises(TypeError) as cm:
+            ta.time = 0.0
+            ta.propagate_grid([0.0, 1.0, 2.0], callback=broken_cb())
+        self.assertTrue(
+            "The call operator of a step callback is expected to return a boolean, but a value of type"
+            in str(cm.exception)
+        )
+
+        # Callback with pre_hook().
+        class cb_hook:
+            def __call__(_, ta):
+                return True
+
+            def pre_hook(self, ta):
+                ta.foo = True
+
+        ta.time = 0.0
+        ta.propagate_until(10.0, callback=cb_hook())
+        self.assertTrue(ta.foo)
+        delattr(ta, "foo")
+
+        ta.time = 0.0
+        ta.propagate_for(10.0, callback=cb_hook())
+        self.assertTrue(ta.foo)
+        delattr(ta, "foo")
+
+        ta.time = 0.0
+        ta.propagate_grid([0.0, 1.0, 2.0], callback=cb_hook())
+        self.assertTrue(ta.foo)
+        delattr(ta, "foo")
+
+    def test_events(self):
+        from . import nt_event, t_event, make_vars, sin, taylor_adaptive
+
+        x, v = make_vars("x", "v")
+
+        # Use a pendulum for testing purposes.
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        def cb0(ta, t, d_sgn):
+            pass
+
+        ta = taylor_adaptive(
+            sys=sys,
+            state=[0.0, 0.25],
+            nt_events=[nt_event(v * v - 1e-10, cb0)],
+            t_events=[t_event(v)],
+        )
+
+        self.assertTrue(ta.with_events)
+        self.assertEqual(len(ta.t_events), 1)
+        self.assertEqual(len(ta.nt_events), 1)
+
+        oc = ta.propagate_until(1e9)[0]
+        self.assertEqual(int(oc), -1)
+        self.assertFalse(ta.te_cooldowns[0] is None)
+
+        ta.reset_cooldowns()
+        self.assertTrue(ta.te_cooldowns[0] is None)
+
+    def test_s11n(self):
+        from . import nt_event, make_vars, sin, taylor_adaptive, core
+        from .core import _ppc_arch
+        import numpy as np
+        import pickle
+
+        x, v = make_vars("x", "v")
+
+        if _ppc_arch:
+            fp_types = [float]
+        else:
+            fp_types = [float, np.longdouble]
+
+        if hasattr(core, "real128"):
+            fp_types.append(core.real128)
+
+        # Use a pendulum for testing purposes.
+        sys = [(x, v), (v, -9.8 * sin(x))]
+
+        def cb0(ta, t, d_sgn):
+            pass
+
+        for fp_t in fp_types:
+            ta = taylor_adaptive(
+                sys=sys,
+                state=[fp_t(0), fp_t(0.25)],
+                fp_type=fp_t,
+                nt_events=[nt_event(v * v - 1e-10, cb0, fp_type=fp_t)],
+            )
+
+            ta.step()
+            ta.step()
+            ta.step()
+            ta.step()
+
+            ta2 = pickle.loads(pickle.dumps(ta))
+
+            self.assertEqual(len(ta.t_events), len(ta2.t_events))
+            self.assertEqual(len(ta.nt_events), len(ta2.nt_events))
+
+            # Test dynamic attributes.
+            ta.foo = "hello world"
+            ta = pickle.loads(pickle.dumps(ta))
+            self.assertEqual(ta.foo, "hello world")
+
+            self.assertTrue(np.all(ta.state == ta2.state))
+            self.assertTrue(np.all(ta.time == ta2.time))
+
+            ta.step()
+            ta2.step()
+
+            self.assertTrue(np.all(ta.state == ta2.state))
+            self.assertTrue(np.all(ta.time == ta2.time))
+
+            # Try also an integrator with stateful event callback.
+            class cb1:
+                def __init__(self):
+                    self.n = 0
+
+                def __call__(self, ta, t, d_sgn):
+                    self.n = self.n + 1
+
+            clb = cb1()
+            ta = taylor_adaptive(
+                sys=sys,
+                state=[fp_t(0), fp_t(0.25)],
+                fp_type=fp_t,
+                nt_events=[nt_event(v * v - 1e-10, clb, fp_type=fp_t)],
+            )
+
+            self.assertNotEqual(id(clb), id(ta.nt_events[0].callback))
+
+            self.assertEqual(ta.nt_events[0].callback.n, 0)
+
+            ta.propagate_until(fp_t(10))
+
+            ta2 = pickle.loads(pickle.dumps(ta))
+
+            self.assertEqual(ta.nt_events[0].callback.n, ta2.nt_events[0].callback.n)
+
+            # Test dynamic attributes.
+            ta.foo = "hello world"
+            ta = pickle.loads(pickle.dumps(ta))
+            self.assertEqual(ta.foo, "hello world")
+
+            ta = taylor_adaptive(
+                sys=sys, state=[fp_t(0), fp_t(0.25)], fp_type=fp_t, tol=fp_t(1e-6)
+            )
+
+            self.assertEqual(ta.tol, fp_t(1e-6))
+
+        # Check throwing behaviour with long double on PPC.
+        if _ppc_arch:
+            fp_t = np.longdouble
+
+            with self.assertRaises(NotImplementedError):
+                taylor_adaptive(
+                    sys=sys, state=[fp_t(0), fp_t(0.25)], fp_type=np.longdouble
+                )
diff --git a/heyoka/common_utils.hpp b/heyoka/common_utils.hpp
index 49112c2e..3963a8e8 100644
--- a/heyoka/common_utils.hpp
+++ b/heyoka/common_utils.hpp
@@ -11,9 +11,7 @@
 
 #include <array>
 #include <cstddef>
-#include <functional>
 #include <string>
-#include <utility>
 
 #if defined(__GLIBCXX__)
 
@@ -142,29 +140,6 @@ py::object deepcopy_wrapper(py::object o, py::dict memo)
     return ret;
 }
 
-// NOTE: this helper wraps a callback for the propagate_*()
-// functions ensuring that the GIL is acquired before invoking the callback.
-// Additionally, the returned wrapper will contain a const reference to the
-// original callback. This ensures that copying the wrapper does not
-// copy the original callback, so that copying the wrapper
-// never ends up calling into the Python interpreter.
-// If cb is an empty callback, a copy of cb will be returned.
-template <typename T>
-inline auto make_prop_cb(const std::function<bool(T &)> &cb)
-{
-    if (cb) {
-        auto ret = [&cb](T &ta) {
-            py::gil_scoped_acquire acquire;
-
-            return cb(ta);
-        };
-
-        return std::function<bool(T &)>(std::move(ret));
-    } else {
-        return cb;
-    }
-}
-
 // Helper to check if a list of arrays may share any memory with each other.
 // Quadratic complexity.
 bool may_share_memory(const py::array &, const py::array &);
diff --git a/heyoka/expose_batch_integrators.cpp b/heyoka/expose_batch_integrators.cpp
index 18b6f6dd..5f43c74a 100644
--- a/heyoka/expose_batch_integrators.cpp
+++ b/heyoka/expose_batch_integrators.cpp
@@ -8,7 +8,6 @@
 
 #include <cstddef>
 #include <cstdint>
-#include <functional>
 #include <optional>
 #include <sstream>
 #include <string>
@@ -22,19 +21,20 @@
 
 #include <Python.h>
 
-#include <pybind11/functional.h>
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
 #include <heyoka/expression.hpp>
 #include <heyoka/llvm_state.hpp>
+#include <heyoka/step_callback.hpp>
 #include <heyoka/taylor.hpp>
 
 #include "common_utils.hpp"
 #include "dtypes.hpp"
 #include "expose_batch_integrators.hpp"
 #include "pickle_wrappers.hpp"
+#include "step_cb_wrapper.hpp"
 
 namespace heyoka_py
 {
@@ -54,10 +54,6 @@ void expose_batch_integrator_impl(py::module_ &m, const std::string &suffix)
     namespace kw = hey::kw;
     using namespace pybind11::literals;
 
-    // The callback for the propagate_*() functions for
-    // the batch integrator.
-    using prop_cb_t = std::function<bool(hey::taylor_adaptive_batch<T> &)>;
-
     // Event types for the batch integrator.
     using t_ev_t = hey::t_event_batch<T>;
     using nt_ev_t = hey::nt_event_batch<T>;
@@ -211,46 +207,67 @@ void expose_batch_integrator_impl(py::module_ &m, const std::string &suffix)
         .def(
             "propagate_for",
             [](hey::taylor_adaptive_batch<T> &ta, const std::variant<T, std::vector<T>> &delta_t, std::size_t max_steps,
-               std::variant<T, std::vector<T>> max_delta_t, const prop_cb_t &cb_, bool write_tc, bool c_output) {
+               std::variant<T, std::vector<T>> max_delta_t, std::optional<py::object> &cb_, bool write_tc,
+               bool c_output) {
                 return std::visit(
                     [&](const auto &dt, auto max_dts) {
-                        // Create the callback wrapper.
-                        auto cb = make_prop_cb(cb_);
-
-                        // NOTE: after releasing the GIL here, the only potential
-                        // calls into the Python interpreter are when invoking cb
-                        // or the events' callbacks (which are all protected by GIL reacquire).
-                        // Note that copying cb around or destroying it is harmless, as it contains only
-                        // a reference to the original callback cb_, or it is an empty callback.
-                        py::gil_scoped_release release;
-                        return ta.propagate_for(dt, kw::max_steps = max_steps, kw::max_delta_t = std::move(max_dts),
-                                                kw::callback = cb, kw::write_tc = write_tc, kw::c_output = c_output);
+                        // NOTE: after releasing the GIL, the only potential
+                        // calls into the Python interpreter are when invoking the event or
+                        // step callbacks (which are all protected by GIL reacquire).
+
+                        if (cb_) {
+                            // NOTE: because cb is a step_callback_batch, it will be passed by reference
+                            // into the propagate_for() function. Thus, no copies are made and no
+                            // calling into the Python interpreter takes place (and no need to hold
+                            // the GIL).
+                            // NOTE: because cb is created before the GIL scoped releaser, it will be
+                            // destroyed *after* the GIL has been re-acquired. Thus, the reference
+                            // count decrease associated with the destructor is safe.
+                            auto cb = hey::step_callback_batch<T>(step_cb_wrapper(*cb_));
+
+                            py::gil_scoped_release release;
+                            return ta.propagate_for(dt, kw::max_steps = max_steps, kw::max_delta_t = std::move(max_dts),
+                                                    kw::callback = cb, kw::write_tc = write_tc,
+                                                    kw::c_output = c_output);
+                        } else {
+                            py::gil_scoped_release release;
+                            return ta.propagate_for(dt, kw::max_steps = max_steps, kw::max_delta_t = std::move(max_dts),
+                                                    kw::write_tc = write_tc, kw::c_output = c_output);
+                        }
                     },
                     delta_t, std::move(max_delta_t));
             },
             "delta_t"_a.noconvert(), "max_steps"_a = 0, "max_delta_t"_a.noconvert() = std::vector<T>{},
-            "callback"_a = prop_cb_t{}, "write_tc"_a = false, "c_output"_a = false)
+            "callback"_a = py::none{}, "write_tc"_a = false, "c_output"_a = false)
         .def(
             "propagate_until",
             [](hey::taylor_adaptive_batch<T> &ta, const std::variant<T, std::vector<T>> &tm, std::size_t max_steps,
-               std::variant<T, std::vector<T>> max_delta_t, const prop_cb_t &cb_, bool write_tc, bool c_output) {
+               std::variant<T, std::vector<T>> max_delta_t, std::optional<py::object> &cb_, bool write_tc,
+               bool c_output) {
                 return std::visit(
                     [&](const auto &t, auto max_dts) {
-                        // Create the callback wrapper.
-                        auto cb = make_prop_cb(cb_);
+                        if (cb_) {
+                            auto cb = hey::step_callback_batch<T>(step_cb_wrapper(*cb_));
 
-                        py::gil_scoped_release release;
-                        return ta.propagate_until(t, kw::max_steps = max_steps, kw::max_delta_t = std::move(max_dts),
-                                                  kw::callback = cb, kw::write_tc = write_tc, kw::c_output = c_output);
+                            py::gil_scoped_release release;
+                            return ta.propagate_until(t, kw::max_steps = max_steps,
+                                                      kw::max_delta_t = std::move(max_dts), kw::callback = cb,
+                                                      kw::write_tc = write_tc, kw::c_output = c_output);
+                        } else {
+                            py::gil_scoped_release release;
+                            return ta.propagate_until(t, kw::max_steps = max_steps,
+                                                      kw::max_delta_t = std::move(max_dts), kw::write_tc = write_tc,
+                                                      kw::c_output = c_output);
+                        }
                     },
                     tm, std::move(max_delta_t));
             },
             "t"_a.noconvert(), "max_steps"_a = 0, "max_delta_t"_a.noconvert() = std::vector<T>{},
-            "callback"_a = prop_cb_t{}, "write_tc"_a = false, "c_output"_a = false)
+            "callback"_a = py::none{}, "write_tc"_a = false, "c_output"_a = false)
         .def(
             "propagate_grid",
             [](hey::taylor_adaptive_batch<T> &ta, const py::iterable &grid_ob, std::size_t max_steps,
-               std::variant<T, std::vector<T>> max_delta_t, const prop_cb_t &cb_) {
+               std::variant<T, std::vector<T>> max_delta_t, std::optional<py::object> &cb_) {
                 return std::visit(
                     [&](auto max_dts) {
                         // Attempt to convert grid_ob to an array.
@@ -289,17 +306,22 @@ void expose_batch_integrator_impl(py::module_ &m, const std::string &suffix)
                         const auto grid_v_size = grid_v.size();
 #endif
 
-                        // Create the callback wrapper.
-                        auto cb = make_prop_cb(cb_);
-
                         // Run the propagation.
                         // NOTE: for batch integrators, ret is guaranteed to always have
                         // the same size regardless of errors.
                         decltype(ta.propagate_grid(grid_v, max_steps)) ret;
                         {
-                            py::gil_scoped_release release;
-                            ret = ta.propagate_grid(std::move(grid_v), kw::max_steps = max_steps,
-                                                    kw::max_delta_t = std::move(max_dts), kw::callback = cb);
+                            if (cb_) {
+                                auto cb = hey::step_callback_batch<T>(step_cb_wrapper(*cb_));
+
+                                py::gil_scoped_release release;
+                                ret = ta.propagate_grid(std::move(grid_v), kw::max_steps = max_steps,
+                                                        kw::max_delta_t = std::move(max_dts), kw::callback = cb);
+                            } else {
+                                py::gil_scoped_release release;
+                                ret = ta.propagate_grid(std::move(grid_v), kw::max_steps = max_steps,
+                                                        kw::max_delta_t = std::move(max_dts));
+                            }
                         }
 
                         // Create the output array.
@@ -314,7 +336,7 @@ void expose_batch_integrator_impl(py::module_ &m, const std::string &suffix)
                     },
                     std::move(max_delta_t));
             },
-            "grid"_a, "max_steps"_a = 0, "max_delta_t"_a.noconvert() = std::vector<T>{}, "callback"_a = prop_cb_t{})
+            "grid"_a, "max_steps"_a = 0, "max_delta_t"_a.noconvert() = std::vector<T>{}, "callback"_a = py::none{})
         .def_property_readonly("propagate_res", &hey::taylor_adaptive_batch<T>::get_propagate_res)
         .def_property_readonly(
             "time",
diff --git a/heyoka/step_cb_wrapper.cpp b/heyoka/step_cb_wrapper.cpp
new file mode 100644
index 00000000..1c0c669a
--- /dev/null
+++ b/heyoka/step_cb_wrapper.cpp
@@ -0,0 +1,120 @@
+// Copyright 2020, 2021, 2022, 2023 Francesco Biscani (bluescarni@gmail.com), Dario Izzo (dario.izzo@gmail.com)
+//
+// This file is part of the heyoka.py library.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include <heyoka/config.hpp>
+
+#include <utility>
+
+#include <fmt/core.h>
+
+#include <pybind11/pybind11.h>
+
+#include <Python.h>
+
+#if defined(HEYOKA_HAVE_REAL128)
+
+#include <mp++/real128.hpp>
+
+#endif
+
+#if defined(HEYOKA_HAVE_REAL)
+
+#include <mp++/real.hpp>
+
+#endif
+
+#include <heyoka/taylor.hpp>
+
+#include "common_utils.hpp"
+#include "step_cb_wrapper.hpp"
+
+namespace heyoka_py
+{
+
+namespace py = pybind11;
+
+// NOTE: m_obj will be a reference to the original Python object.
+// Unlike the event callbacks we don't want to do any deep copy
+// here - in ensemble propagations, we will be manually deep-copying
+// the Python callbacks before invoking the propagate_*() member
+// functions.
+step_cb_wrapper::step_cb_wrapper(py::object obj) : m_obj(std::move(obj))
+{
+    if (!callable(m_obj)) {
+        py_throw(PyExc_TypeError,
+                 fmt::format("An object of type '{}' cannot be used as a step callback because it is not callable",
+                             str(type(m_obj)))
+                     .c_str());
+    }
+}
+
+template <typename TA>
+bool step_cb_wrapper::operator()(TA &ta)
+{
+    py::gil_scoped_acquire acquire;
+
+    // NOTE: this will return a reference
+    // to the Python object wrapping ta.
+    auto ta_obj = py::cast(&ta);
+
+    // Attempt to invoke the call operator of the
+    // Pythonic callback.
+    auto ret = m_obj(ta_obj);
+
+    // NOTE: we want to manually check the conversion
+    // of the return value because if that fails
+    // the pybind11 error message is not very helpful, and thus
+    // we try to provide a more detailed error message.
+    try {
+        return py::cast<bool>(ret);
+    } catch (const py::cast_error &) {
+        py_throw(PyExc_TypeError, (fmt::format("The call operator of a step callback is expected to return a boolean, "
+                                               "but a value of type '{}' was returned instead",
+                                               str(type(ret))))
+                                      .c_str());
+    }
+}
+
+template <typename TA>
+void step_cb_wrapper::pre_hook(TA &ta)
+{
+    py::gil_scoped_acquire acquire;
+
+    if (py::hasattr(m_obj, "pre_hook")) {
+        auto ta_obj = py::cast(&ta);
+
+        m_obj.attr("pre_hook")(ta_obj);
+    }
+}
+
+// Explicit instantiations.
+
+template bool step_cb_wrapper::operator()(heyoka::taylor_adaptive<double> &);
+template void step_cb_wrapper::pre_hook(heyoka::taylor_adaptive<double> &);
+
+template bool step_cb_wrapper::operator()(heyoka::taylor_adaptive<long double> &);
+template void step_cb_wrapper::pre_hook(heyoka::taylor_adaptive<long double> &);
+
+#if defined(HEYOKA_HAVE_REAL128)
+
+template bool step_cb_wrapper::operator()(heyoka::taylor_adaptive<mppp::real128> &);
+template void step_cb_wrapper::pre_hook(heyoka::taylor_adaptive<mppp::real128> &);
+
+#endif
+
+#if defined(HEYOKA_HAVE_REAL)
+
+template bool step_cb_wrapper::operator()(heyoka::taylor_adaptive<mppp::real> &);
+template void step_cb_wrapper::pre_hook(heyoka::taylor_adaptive<mppp::real> &);
+
+#endif
+
+template bool step_cb_wrapper::operator()(heyoka::taylor_adaptive_batch<double> &);
+template void step_cb_wrapper::pre_hook(heyoka::taylor_adaptive_batch<double> &);
+
+} // namespace heyoka_py
diff --git a/heyoka/step_cb_wrapper.hpp b/heyoka/step_cb_wrapper.hpp
new file mode 100644
index 00000000..4887e296
--- /dev/null
+++ b/heyoka/step_cb_wrapper.hpp
@@ -0,0 +1,41 @@
+// Copyright 2020, 2021, 2022, 2023 Francesco Biscani (bluescarni@gmail.com), Dario Izzo (dario.izzo@gmail.com)
+//
+// This file is part of the heyoka.py library.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef HEYOKA_PY_STEP_CB_WRAPPER_HPP
+#define HEYOKA_PY_STEP_CB_WRAPPER_HPP
+
+#include <pybind11/pybind11.h>
+
+namespace heyoka_py
+{
+
+namespace py = pybind11;
+
+// NOTE: the purpose of this wrapper is to enforce
+// GIL acquisition when invoking the call operator
+// or the pre_hook() function. This is needed because
+// the GIL is released during the invocation of the
+// propagate_*() functions. See also the event callback
+// wrapper, which does the same thing.
+class step_cb_wrapper
+{
+    py::object m_obj;
+
+public:
+    explicit step_cb_wrapper(py::object);
+
+    template <typename TA>
+    bool operator()(TA &);
+
+    template <typename TA>
+    void pre_hook(TA &);
+};
+
+} // namespace heyoka_py
+
+#endif
diff --git a/heyoka/taylor_expose_events.cpp b/heyoka/taylor_expose_events.cpp
index 18173d49..b8be3e11 100644
--- a/heyoka/taylor_expose_events.cpp
+++ b/heyoka/taylor_expose_events.cpp
@@ -69,16 +69,18 @@ namespace
 //   performs a deep copy),
 // - ensure the GIL is acquired in the call operator,
 // - provide serialisation capabilities.
-// NOTE: the deep copy behaviour needs to be highlighted
-// in the docs, as it has consequences on how one writes
-// the callbacks.
+// NOTE: the deep copy behaviour can be inconvenient
+// on the Python side, but it is useful as a first line
+// of defense in ensemble propagations. By forcing a copy,
+// we are reducing the chances of data races in stateful
+// callbacks.
 template <typename Ret, typename... Args>
 struct ev_callback {
     py::object m_obj;
 
     ev_callback() = default;
-    explicit ev_callback(py::object o) : m_obj(std::move(o)) {}
-    ev_callback(const ev_callback &c) : m_obj(py::module_::import("copy").attr("deepcopy")(c.m_obj)) {}
+    explicit ev_callback(py::object o) : m_obj(py::module_::import("copy").attr("deepcopy")(o)) {}
+    ev_callback(const ev_callback &c) : ev_callback(c.m_obj) {}
     ev_callback(ev_callback &&) noexcept = default;
     ev_callback &operator=(const ev_callback &c)
     {
@@ -89,6 +91,7 @@ struct ev_callback {
         return *this;
     }
     ev_callback &operator=(ev_callback &&) noexcept = default;
+    ~ev_callback() = default;
 
     Ret operator()(Args... args) const
     {
diff --git a/heyoka/taylor_expose_integrator.cpp b/heyoka/taylor_expose_integrator.cpp
index d9febe9a..0d157317 100644
--- a/heyoka/taylor_expose_integrator.cpp
+++ b/heyoka/taylor_expose_integrator.cpp
@@ -11,8 +11,8 @@
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
-#include <functional>
 #include <initializer_list>
+#include <optional>
 #include <sstream>
 #include <string>
 #include <tuple>
@@ -25,7 +25,6 @@
 
 #include <fmt/format.h>
 
-#include <pybind11/functional.h>
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
@@ -45,12 +44,14 @@
 #endif
 
 #include <heyoka/expression.hpp>
+#include <heyoka/step_callback.hpp>
 #include <heyoka/taylor.hpp>
 
 #include "common_utils.hpp"
 #include "custom_casters.hpp"
 #include "dtypes.hpp"
 #include "pickle_wrappers.hpp"
+#include "step_cb_wrapper.hpp"
 #include "taylor_expose_integrator.hpp"
 
 namespace heyoka_py
@@ -74,8 +75,7 @@ constexpr bool default_cm =
 #endif
     ;
 
-// Implementation of the exposition of the scalar integrators
-// for double and long double.
+// Implementation of the exposition of the scalar integrators.
 template <typename T>
 void expose_taylor_integrator_impl(py::module &m, const std::string &suffix)
 {
@@ -84,7 +84,6 @@ void expose_taylor_integrator_impl(py::module &m, const std::string &suffix)
 
     using t_ev_t = hey::t_event<T>;
     using nt_ev_t = hey::nt_event<T>;
-    using prop_cb_t = std::function<bool(hey::taylor_adaptive<T> &)>;
 
     // Union of ODE system types, used in the ctor.
     using sys_t = std::variant<std::vector<std::pair<hey::expression, hey::expression>>, std::vector<hey::expression>>;
@@ -206,50 +205,71 @@ void expose_taylor_integrator_impl(py::module &m, const std::string &suffix)
         // propagate_*().
         .def(
             "propagate_for",
-            [](hey::taylor_adaptive<T> &ta, T delta_t, std::size_t max_steps, T max_delta_t, const prop_cb_t &cb_,
-               bool write_tc, bool c_output) {
-                // Create the callback wrapper.
-                auto cb = make_prop_cb(cb_);
-
-                // NOTE: after releasing the GIL here, the only potential
-                // calls into the Python interpreter are when invoking cb
-                // or the events' callbacks (which are all protected by GIL reacquire).
-                // Note that copying cb around or destroying it is harmless, as it contains only
-                // a reference to the original callback cb_, or it is an empty callback.
-                py::gil_scoped_release release;
-                return ta.propagate_for(delta_t, kw::max_steps = max_steps, kw::max_delta_t = max_delta_t,
-                                        kw::callback = cb, kw::write_tc = write_tc, kw::c_output = c_output);
+            [](hey::taylor_adaptive<T> &ta, T delta_t, std::size_t max_steps, T max_delta_t,
+               std::optional<py::object> &cb_, bool write_tc, bool c_output) {
+                // NOTE: after releasing the GIL, the only potential
+                // calls into the Python interpreter are when invoking the event or
+                // step callbacks (which are all protected by GIL reacquire).
+
+                if (cb_) {
+                    // NOTE: because cb is a step_callback, it will be passed by reference
+                    // into the propagate_for() function. Thus, no copies are made and no
+                    // calling into the Python interpreter takes place (and no need to hold
+                    // the GIL).
+                    // NOTE: because cb is created before the GIL scoped releaser, it will be
+                    // destroyed *after* the GIL has been re-acquired. Thus, the reference
+                    // count decrease associated with the destructor is safe.
+                    auto cb = hey::step_callback<T>(step_cb_wrapper(*cb_));
+
+                    py::gil_scoped_release release;
+                    return ta.propagate_for(delta_t, kw::max_steps = max_steps, kw::max_delta_t = max_delta_t,
+                                            kw::write_tc = write_tc, kw::c_output = c_output, kw::callback = cb);
+                } else {
+                    py::gil_scoped_release release;
+                    return ta.propagate_for(delta_t, kw::max_steps = max_steps, kw::max_delta_t = max_delta_t,
+                                            kw::write_tc = write_tc, kw::c_output = c_output);
+                }
             },
             "delta_t"_a.noconvert(), "max_steps"_a = 0,
-            "max_delta_t"_a.noconvert() = hey::detail::taylor_default_max_delta_t<T>(), "callback"_a = prop_cb_t{},
+            "max_delta_t"_a.noconvert() = hey::detail::taylor_default_max_delta_t<T>(), "callback"_a = py::none{},
             "write_tc"_a = false, "c_output"_a = false)
         .def(
             "propagate_until",
-            [](hey::taylor_adaptive<T> &ta, T t, std::size_t max_steps, T max_delta_t, const prop_cb_t &cb_,
+            [](hey::taylor_adaptive<T> &ta, T t, std::size_t max_steps, T max_delta_t, std::optional<py::object> &cb_,
                bool write_tc, bool c_output) {
-                // Create the callback wrapper.
-                auto cb = make_prop_cb(cb_);
+                if (cb_) {
+                    auto cb = hey::step_callback<T>(step_cb_wrapper(*cb_));
 
-                py::gil_scoped_release release;
-                return ta.propagate_until(t, kw::max_steps = max_steps, kw::max_delta_t = max_delta_t,
-                                          kw::callback = cb, kw::write_tc = write_tc, kw::c_output = c_output);
+                    py::gil_scoped_release release;
+                    return ta.propagate_until(t, kw::max_steps = max_steps, kw::max_delta_t = max_delta_t,
+                                              kw::write_tc = write_tc, kw::c_output = c_output, kw::callback = cb);
+                } else {
+                    py::gil_scoped_release release;
+                    return ta.propagate_until(t, kw::max_steps = max_steps, kw::max_delta_t = max_delta_t,
+                                              kw::write_tc = write_tc, kw::c_output = c_output);
+                }
             },
             "t"_a.noconvert(), "max_steps"_a = 0,
-            "max_delta_t"_a.noconvert() = hey::detail::taylor_default_max_delta_t<T>(), "callback"_a = prop_cb_t{},
+            "max_delta_t"_a.noconvert() = hey::detail::taylor_default_max_delta_t<T>(), "callback"_a = py::none{},
             "write_tc"_a = false, "c_output"_a = false)
         .def(
             "propagate_grid",
             [](hey::taylor_adaptive<T> &ta, std::vector<T> grid, std::size_t max_steps, T max_delta_t,
-               const prop_cb_t &cb_) {
-                // Create the callback wrapper.
-                auto cb = make_prop_cb(cb_);
-
+               std::optional<py::object> &cb_) {
                 decltype(ta.propagate_grid(grid, max_steps)) ret;
 
                 {
-                    py::gil_scoped_release release;
-                    ret = ta.propagate_grid(std::move(grid), kw::max_steps = max_steps, kw::max_delta_t = max_delta_t,
-                                            kw::callback = cb);
+                    if (cb_) {
+                        auto cb = hey::step_callback<T>(step_cb_wrapper(*cb_));
+
+                        py::gil_scoped_release release;
+                        ret = ta.propagate_grid(std::move(grid), kw::max_steps = max_steps,
+                                                kw::max_delta_t = max_delta_t, kw::callback = cb);
+                    } else {
+                        py::gil_scoped_release release;
+                        ret = ta.propagate_grid(std::move(grid), kw::max_steps = max_steps,
+                                                kw::max_delta_t = max_delta_t);
+                    }
                 }
 
                 // Determine the number of state vectors returned
@@ -266,7 +286,7 @@ void expose_taylor_integrator_impl(py::module &m, const std::string &suffix)
                                       std::move(a_ret));
             },
             "grid"_a.noconvert(), "max_steps"_a = 0,
-            "max_delta_t"_a.noconvert() = hey::detail::taylor_default_max_delta_t<T>(), "callback"_a = prop_cb_t{})
+            "max_delta_t"_a.noconvert() = hey::detail::taylor_default_max_delta_t<T>(), "callback"_a = py::none{})
         // Repr.
         .def("__repr__",
              [](const hey::taylor_adaptive<T> &ta) {
diff --git a/heyoka/test.py b/heyoka/test.py
index 286f97b8..47f61b48 100644
--- a/heyoka/test.py
+++ b/heyoka/test.py
@@ -605,7 +605,7 @@ def __call__(self, ta, t, d_sgn):
             self.assertEqual(ev.callback.n, 3)
             ev.callback.n = 0
             self.assertEqual(ev.callback.n, 0)
-            self.assertEqual(id(lcb), id(ev.callback))
+            self.assertNotEqual(id(lcb), id(ev.callback))
 
             with self.assertRaises(ValueError) as cm:
                 nt_event(
@@ -759,7 +759,7 @@ def __call__(self, ta, mr, d_sgn):
             self.assertEqual(ev.callback.n, 3)
             ev.callback.n = 0
             self.assertEqual(ev.callback.n, 0)
-            self.assertEqual(id(lcb), id(ev.callback))
+            self.assertNotEqual(id(lcb), id(ev.callback))
 
             ev = t_event(
                 x + v,
@@ -921,7 +921,7 @@ def __call__(self, ta, t, d_sgn):
         self.assertEqual(ev.callback.n, 3)
         ev.callback.n = 0
         self.assertEqual(ev.callback.n, 0)
-        self.assertEqual(id(lcb), id(ev.callback))
+        self.assertNotEqual(id(lcb), id(ev.callback))
 
         with self.assertRaises(ValueError) as cm:
             nt_event_batch(
@@ -1057,7 +1057,7 @@ def __call__(self, ta, mr, d_sgn):
         self.assertEqual(ev.callback.n, 3)
         ev.callback.n = 0
         self.assertEqual(ev.callback.n, 0)
-        self.assertEqual(id(lcb), id(ev.callback))
+        self.assertNotEqual(id(lcb), id(ev.callback))
 
         ev = t_event_batch(
             x + v, direction=event_direction.positive, cooldown=fp_t(3), callback=None
@@ -1789,913 +1789,6 @@ def cb3(ta, mr, d_sgn):
             )
 
 
-class scalar_integrator_test_case(_ut.TestCase):
-    def test_type_conversions(self):
-        # Test to check automatic conversions of std::vector<T>
-        # in the integrator's constructor.
-
-        from . import taylor_adaptive, make_vars, sin
-        import numpy as np
-
-        d_digs = np.finfo(np.double).nmant
-        ld_digs = np.finfo(np.longdouble).nmant
-
-        x, v = make_vars("x", "v")
-
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        ta = taylor_adaptive(sys=sys, state=(0.0, 0.25), tol=1e-4)
-        self.assertTrue(np.all(ta.state == [0.0, 0.25]))
-        ta = taylor_adaptive(sys=sys, state=np.array([0.0, 0.25]), tol=1e-4)
-        self.assertTrue(np.all(ta.state == [0.0, 0.25]))
-
-        if d_digs == ld_digs:
-            return
-
-        # Check that conversion from other fp types is forbidden.
-        with self.assertRaises(TypeError) as cm:
-            ta = taylor_adaptive(
-                sys=sys, state=(np.longdouble(0.0), np.longdouble(0.25)), tol=1e-4
-            )
-
-        with self.assertRaises(TypeError) as cm:
-            ta = taylor_adaptive(
-                sys=sys, state=np.array([0.0, 0.25], dtype=np.longdouble), tol=1e-4
-            )
-
-    def test_dtime(self):
-        from . import taylor_adaptive, make_vars, sin
-
-        x, v = make_vars("x", "v")
-
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        ta = taylor_adaptive(sys=sys, state=[0.0, 0.25])
-
-        self.assertEqual(ta.dtime, (0.0, 0.0))
-
-        ta.step()
-        ta.propagate_for(1001.1)
-
-        self.assertTrue(ta.dtime[1] != 0)
-
-        ta.dtime = (1, 0.5)
-
-        self.assertEqual(ta.dtime, (1.5, 0.0))
-
-    def test_copy(self):
-        from . import taylor_adaptive, make_vars, t_event, sin
-        import numpy as np
-        from copy import copy, deepcopy
-
-        x, v = make_vars("x", "v")
-
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        ta = taylor_adaptive(sys=sys, state=[0.0, 0.25], t_events=[t_event(v)])
-
-        ta.step()
-
-        class foo:
-            pass
-
-        ta.bar = foo()
-
-        self.assertEqual(id(ta.bar), id(copy(ta).bar))
-        self.assertNotEqual(id(ta.bar), id(deepcopy(ta).bar))
-        self.assertTrue(np.all(ta.state == copy(ta).state))
-        self.assertTrue(np.all(ta.state == deepcopy(ta).state))
-
-        ta_dc = deepcopy(ta)
-        self.assertEqual(ta_dc.state[0], ta.state[0])
-        ta.state[0] += 1
-        self.assertNotEqual(ta_dc.state[0], ta.state[0])
-
-    def test_basic(self):
-        from . import taylor_adaptive, make_vars, t_event, sin
-
-        x, v = make_vars("x", "v")
-
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        ta = taylor_adaptive(sys=sys, state=[0.0, 0.25], t_events=[t_event(v)])
-
-        self.assertTrue(ta.with_events)
-        self.assertFalse(ta.compact_mode)
-        self.assertFalse(ta.high_accuracy)
-        self.assertEqual(ta.state_vars, [x, v])
-        self.assertEqual(ta.rhs, [v, -9.8 * sin(x)])
-
-        ta = taylor_adaptive(
-            sys=sys, state=[0.0, 0.25], compact_mode=True, high_accuracy=True
-        )
-
-        self.assertFalse(ta.with_events)
-        self.assertTrue(ta.compact_mode)
-        self.assertTrue(ta.high_accuracy)
-        self.assertFalse(ta.llvm_state.fast_math)
-        self.assertFalse(ta.llvm_state.force_avx512)
-        self.assertEqual(ta.llvm_state.opt_level, 3)
-
-        # Check that certain properties are read-only
-        # arrays and the writeability cannot be changed.
-        self.assertFalse(ta.tc.flags.writeable)
-        with self.assertRaises(ValueError):
-            ta.tc.flags.writeable = True
-        self.assertFalse(ta.d_output.flags.writeable)
-        with self.assertRaises(ValueError):
-            ta.d_output.flags.writeable = True
-
-        # Test the custom llvm_state flags.
-        ta = taylor_adaptive(
-            sys=sys,
-            state=[0.0, 0.25],
-            compact_mode=True,
-            high_accuracy=True,
-            force_avx512=True,
-            fast_math=True,
-            opt_level=0,
-        )
-
-        self.assertTrue(ta.llvm_state.fast_math)
-        self.assertTrue(ta.llvm_state.force_avx512)
-        self.assertEqual(ta.llvm_state.opt_level, 0)
-
-        # Test that adding dynattrs to the integrator
-        # object via the propagate callback works.
-        def cb(ta):
-            if hasattr(ta, "counter"):
-                ta.counter += 1
-            else:
-                ta.counter = 0
-
-            return True
-
-        ta.propagate_until(10.0, callback=cb)
-
-        self.assertTrue(ta.counter > 0)
-        orig_ct = ta.counter
-
-        ta.propagate_for(10.0, callback=cb)
-
-        self.assertTrue(ta.counter > orig_ct)
-        orig_ct = ta.counter
-
-        ta.time = 0.0
-        ta.propagate_grid([0.0, 1.0, 2.0], callback=cb)
-
-        self.assertTrue(ta.counter > orig_ct)
-
-        # Test that no copies of the callback are performed.
-        class cb:
-            def __call__(_, ta):
-                self.assertEqual(id(_), _.orig_id)
-
-                return True
-
-        cb_inst = cb()
-        cb_inst.orig_id = id(cb_inst)
-
-        ta.time = 0.0
-        ta.propagate_until(10.0, callback=cb_inst)
-        ta.propagate_for(10.0, callback=cb_inst)
-        ta.time = 0.0
-        ta.propagate_grid([0.0, 1.0, 2.0], callback=cb_inst)
-
-    def test_events(self):
-        from . import nt_event, t_event, make_vars, sin, taylor_adaptive
-
-        x, v = make_vars("x", "v")
-
-        # Use a pendulum for testing purposes.
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        def cb0(ta, t, d_sgn):
-            pass
-
-        ta = taylor_adaptive(
-            sys=sys,
-            state=[0.0, 0.25],
-            nt_events=[nt_event(v * v - 1e-10, cb0)],
-            t_events=[t_event(v)],
-        )
-
-        self.assertTrue(ta.with_events)
-        self.assertEqual(len(ta.t_events), 1)
-        self.assertEqual(len(ta.nt_events), 1)
-
-        oc = ta.propagate_until(1e9)[0]
-        self.assertEqual(int(oc), -1)
-        self.assertFalse(ta.te_cooldowns[0] is None)
-
-        ta.reset_cooldowns()
-        self.assertTrue(ta.te_cooldowns[0] is None)
-
-    def test_s11n(self):
-        from . import nt_event, make_vars, sin, taylor_adaptive, core
-        from .core import _ppc_arch
-        import numpy as np
-        import pickle
-
-        x, v = make_vars("x", "v")
-
-        if _ppc_arch:
-            fp_types = [float]
-        else:
-            fp_types = [float, np.longdouble]
-
-        if hasattr(core, "real128"):
-            fp_types.append(core.real128)
-
-        # Use a pendulum for testing purposes.
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        def cb0(ta, t, d_sgn):
-            pass
-
-        for fp_t in fp_types:
-            ta = taylor_adaptive(
-                sys=sys,
-                state=[fp_t(0), fp_t(0.25)],
-                fp_type=fp_t,
-                nt_events=[nt_event(v * v - 1e-10, cb0, fp_type=fp_t)],
-            )
-
-            ta.step()
-            ta.step()
-            ta.step()
-            ta.step()
-
-            ta2 = pickle.loads(pickle.dumps(ta))
-
-            self.assertEqual(len(ta.t_events), len(ta2.t_events))
-            self.assertEqual(len(ta.nt_events), len(ta2.nt_events))
-
-            # Test dynamic attributes.
-            ta.foo = "hello world"
-            ta = pickle.loads(pickle.dumps(ta))
-            self.assertEqual(ta.foo, "hello world")
-
-            self.assertTrue(np.all(ta.state == ta2.state))
-            self.assertTrue(np.all(ta.time == ta2.time))
-
-            ta.step()
-            ta2.step()
-
-            self.assertTrue(np.all(ta.state == ta2.state))
-            self.assertTrue(np.all(ta.time == ta2.time))
-
-            # Try also an integrator with stateful event callback.
-            class cb1:
-                def __init__(self):
-                    self.n = 0
-
-                def __call__(self, ta, t, d_sgn):
-                    self.n = self.n + 1
-
-            clb = cb1()
-            ta = taylor_adaptive(
-                sys=sys,
-                state=[fp_t(0), fp_t(0.25)],
-                fp_type=fp_t,
-                nt_events=[nt_event(v * v - 1e-10, clb, fp_type=fp_t)],
-            )
-
-            self.assertNotEqual(id(clb), id(ta.nt_events[0].callback))
-
-            self.assertEqual(ta.nt_events[0].callback.n, 0)
-
-            ta.propagate_until(fp_t(10))
-
-            ta2 = pickle.loads(pickle.dumps(ta))
-
-            self.assertEqual(ta.nt_events[0].callback.n, ta2.nt_events[0].callback.n)
-
-            # Test dynamic attributes.
-            ta.foo = "hello world"
-            ta = pickle.loads(pickle.dumps(ta))
-            self.assertEqual(ta.foo, "hello world")
-
-            ta = taylor_adaptive(
-                sys=sys, state=[fp_t(0), fp_t(0.25)], fp_type=fp_t, tol=fp_t(1e-6)
-            )
-
-            self.assertEqual(ta.tol, fp_t(1e-6))
-
-        # Check throwing behaviour with long double on PPC.
-        if _ppc_arch:
-            fp_t = np.longdouble
-
-            with self.assertRaises(NotImplementedError):
-                taylor_adaptive(
-                    sys=sys, state=[fp_t(0), fp_t(0.25)], fp_type=np.longdouble
-                )
-
-
-class batch_integrator_test_case(_ut.TestCase):
-    def test_type_conversions(self):
-        # Test to check automatic conversions of std::vector<T>
-        # in the integrator's constructor.
-
-        from . import taylor_adaptive_batch, make_vars, sin
-        import numpy as np
-
-        d_digs = np.finfo(np.double).nmant
-        ld_digs = np.finfo(np.longdouble).nmant
-
-        x, v = make_vars("x", "v")
-
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        ta = taylor_adaptive_batch(sys=sys, state=((0.0, 0.1), (0.25, 0.26)), tol=1e-4)
-        self.assertTrue(np.all(ta.state == ((0.0, 0.1), (0.25, 0.26))))
-
-        ta = taylor_adaptive_batch(
-            sys=sys, state=np.array([[0.0, 0.1], [0.25, 0.26]]), tol=1e-4
-        )
-        self.assertTrue(np.all(ta.state == ((0.0, 0.1), (0.25, 0.26))))
-
-        if d_digs == ld_digs:
-            return
-
-        ld = np.longdouble
-
-        # Check that conversion from other fp types is forbidden.
-        with self.assertRaises(TypeError) as cm:
-            ta = taylor_adaptive_batch(
-                sys=sys, state=((ld(0.0), ld(0.1)), (ld(0.25), ld(0.26))), tol=1e-4
-            )
-
-        with self.assertRaises(TypeError) as cm:
-            ta = taylor_adaptive_batch(
-                sys=sys, state=np.array([[0.0, 0.1], [0.25, 0.26]], dtype=ld), tol=1e-4
-            )
-
-    def test_copy(self):
-        from . import nt_event_batch, make_vars, sin, taylor_adaptive_batch
-        from copy import copy, deepcopy
-        import numpy as np
-
-        x, v = make_vars("x", "v")
-
-        # Use a pendulum for testing purposes.
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        def cb0(ta, t, d_sgn, bidx):
-            pass
-
-        ta = taylor_adaptive_batch(
-            sys=sys,
-            state=[[0, 0.01], [0.25, 0.26]],
-            nt_events=[nt_event_batch(v * v - 1e-10, cb0)],
-        )
-
-        ta.step()
-        ta.step()
-        ta.step()
-        ta.step()
-
-        class foo:
-            pass
-
-        ta.bar = foo()
-
-        self.assertEqual(id(ta.bar), id(copy(ta).bar))
-        self.assertNotEqual(id(ta.bar), id(deepcopy(ta).bar))
-        self.assertTrue(np.all(ta.state == copy(ta).state))
-        self.assertTrue(np.all(ta.state == deepcopy(ta).state))
-
-        ta_dc = deepcopy(ta)
-        self.assertEqual(ta_dc.state[0, 0], ta.state[0, 0])
-        ta.state[0, 0] += 1
-        self.assertNotEqual(ta_dc.state[0, 0], ta.state[0, 0])
-
-    def test_propagate_for(self):
-        from . import taylor_adaptive_batch, make_vars, sin
-        from copy import deepcopy
-        import numpy as np
-
-        ic = [[0.0, 0.1, 0.2, 0.3], [0.25, 0.26, 0.27, 0.28]]
-
-        x, v = make_vars("x", "v")
-
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        ta = taylor_adaptive_batch(sys=sys, state=ic)
-
-        # Compare vector/scalar delta_t and max_delta_t.
-        ta.propagate_for([10.0] * 4)
-        st = deepcopy(ta.state)
-        res = deepcopy(ta.propagate_res)
-
-        ta.set_time(0.0)
-        ta.state[:] = ic
-
-        ta.propagate_for(10.0)
-        self.assertTrue(np.all(ta.state == st))
-        self.assertEqual(res, ta.propagate_res)
-
-        ta.set_time(0.0)
-        ta.state[:] = ic
-
-        ta.propagate_for([10.0] * 4, max_delta_t=[1e-4] * 4)
-        st = deepcopy(ta.state)
-        res = deepcopy(ta.propagate_res)
-
-        ta.set_time(0.0)
-        ta.state[:] = ic
-
-        ta.propagate_for(10.0, max_delta_t=1e-4)
-        self.assertTrue(np.all(ta.state == st))
-        self.assertEqual(res, ta.propagate_res)
-
-        # Test that adding dynattrs to the integrator
-        # object via the propagate callback works.
-        def cb(ta):
-            if hasattr(ta, "counter"):
-                ta.counter += 1
-            else:
-                ta.counter = 0
-
-            return True
-
-        ta.propagate_for(10.0, callback=cb)
-
-        self.assertTrue(ta.counter > 0)
-
-        # Test that no copies of the callback are performed.
-        class cb:
-            def __call__(_, ta):
-                self.assertEqual(id(_), _.orig_id)
-
-                return True
-
-        cb_inst = cb()
-        cb_inst.orig_id = id(cb_inst)
-
-        ta.propagate_for(10.0, callback=cb_inst)
-
-    def test_propagate_until(self):
-        from . import taylor_adaptive_batch, make_vars, sin
-        from copy import deepcopy
-        import numpy as np
-
-        ic = [[0.0, 0.1, 0.2, 0.3], [0.25, 0.26, 0.27, 0.28]]
-
-        x, v = make_vars("x", "v")
-
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        ta = taylor_adaptive_batch(sys=sys, state=ic)
-
-        # Compare vector/scalar delta_t and max_delta_t.
-        ta.propagate_until([10.0] * 4)
-        st = deepcopy(ta.state)
-        res = deepcopy(ta.propagate_res)
-
-        ta.set_time(0.0)
-        ta.state[:] = ic
-
-        ta.propagate_until(10.0)
-        self.assertTrue(np.all(ta.state == st))
-        self.assertEqual(res, ta.propagate_res)
-
-        ta.set_time(0.0)
-        ta.state[:] = ic
-
-        ta.propagate_until([10.0] * 4, max_delta_t=[1e-4] * 4)
-        st = deepcopy(ta.state)
-        res = deepcopy(ta.propagate_res)
-
-        ta.set_time(0.0)
-        ta.state[:] = ic
-
-        ta.propagate_until(10.0, max_delta_t=1e-4)
-        self.assertTrue(np.all(ta.state == st))
-        self.assertEqual(res, ta.propagate_res)
-
-        # Test that adding dynattrs to the integrator
-        # object via the propagate callback works.
-        def cb(ta):
-            if hasattr(ta, "counter"):
-                ta.counter += 1
-            else:
-                ta.counter = 0
-
-            return True
-
-        ta.propagate_until(20.0, callback=cb)
-
-        self.assertTrue(ta.counter > 0)
-
-        # Test that no copies of the callback are performed.
-        class cb:
-            def __call__(_, ta):
-                self.assertEqual(id(_), _.orig_id)
-
-                return True
-
-        cb_inst = cb()
-        cb_inst.orig_id = id(cb_inst)
-
-        ta.propagate_until(30.0, callback=cb_inst)
-
-    def test_update_d_output(self):
-        from . import taylor_adaptive_batch, make_vars, sin
-        from sys import getrefcount
-        from copy import deepcopy
-        import numpy as np
-
-        x, v = make_vars("x", "v")
-
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        ta = taylor_adaptive_batch(
-            sys=sys, state=[[0.0, 0.1, 0.2, 0.3], [0.25, 0.26, 0.27, 0.28]]
-        )
-
-        ta.step(write_tc=True)
-
-        # Scalar overload.
-        with self.assertRaises(ValueError) as cm:
-            ta.update_d_output(0.3)[0] = 0.5
-
-        d_out = ta.update_d_output(0.3)
-        self.assertEqual(d_out.shape, (2, 4))
-        rc = getrefcount(ta)
-        tmp_out = ta.update_d_output(0.2)
-        new_rc = getrefcount(ta)
-        self.assertEqual(new_rc, rc + 1)
-
-        # Vector overload.
-        with self.assertRaises(ValueError) as cm:
-            ta.update_d_output([0.3, 0.4, 0.45, 0.46])[0] = 0.5
-
-        d_out2 = ta.update_d_output([0.3, 0.4, 0.45, 0.46])
-        self.assertEqual(d_out2.shape, (2, 4))
-        rc = getrefcount(ta)
-        tmp_out2 = ta.update_d_output([0.31, 0.41, 0.66, 0.67])
-        new_rc = getrefcount(ta)
-        self.assertEqual(new_rc, rc + 1)
-
-        cp = deepcopy(ta.update_d_output(0.3))
-        self.assertTrue(np.all(cp == ta.update_d_output([0.3] * 4)))
-
-        # Functional testing.
-        ta.set_time(0.0)
-        ta.state[:] = [[0.0, 0.01, 0.02, 0.03], [0.205, 0.206, 0.207, 0.208]]
-        ta.step(write_tc=True)
-        ta.update_d_output(ta.time)
-        self.assertTrue(
-            np.allclose(
-                ta.d_output,
-                ta.state,
-                rtol=np.finfo(float).eps * 10,
-                atol=np.finfo(float).eps * 10,
-            )
-        )
-        ta.update_d_output(0.0, rel_time=True)
-        self.assertTrue(
-            np.allclose(
-                ta.d_output,
-                ta.state,
-                rtol=np.finfo(float).eps * 10,
-                atol=np.finfo(float).eps * 10,
-            )
-        )
-
-    def test_set_time(self):
-        from . import taylor_adaptive_batch, make_vars, sin
-        import numpy as np
-
-        x, v = make_vars("x", "v")
-
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        ta = taylor_adaptive_batch(sys=sys, state=[[0.0, 0.1], [0.25, 0.26]])
-
-        self.assertTrue(np.all(ta.time == [0, 0]))
-
-        ta.set_time([-1.0, 1.0])
-        self.assertTrue(np.all(ta.time == [-1, 1]))
-
-        ta.set_time(5.0)
-        self.assertTrue(np.all(ta.time == [5, 5]))
-
-    def test_dtime(self):
-        from . import taylor_adaptive_batch, make_vars, sin
-        import numpy as np
-
-        x, v = make_vars("x", "v")
-
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        ta = taylor_adaptive_batch(sys=sys, state=[[0.0, 0.1], [0.25, 0.26]])
-
-        self.assertTrue(np.all(ta.dtime[0] == [0, 0]))
-        self.assertTrue(np.all(ta.dtime[1] == [0, 0]))
-
-        # Check not writeable,
-        with self.assertRaises(ValueError) as cm:
-            ta.dtime[0][0] = 0.5
-
-        with self.assertRaises(ValueError) as cm:
-            ta.dtime[1][0] = 0.5
-
-        ta.step()
-        ta.propagate_for(1000.1)
-
-        self.assertFalse(np.all(ta.dtime[1] == [0, 0]))
-
-        ta.set_dtime(1.0, 0.5)
-
-        self.assertTrue(np.all(ta.dtime[0] == [1.5, 1.5]))
-        self.assertTrue(np.all(ta.dtime[1] == [0, 0]))
-
-        ta.set_dtime([1.0, 2.0], [0.5, 0.25])
-
-        self.assertTrue(np.all(ta.dtime[0] == [1.5, 2.25]))
-        self.assertTrue(np.all(ta.dtime[1] == [0, 0]))
-
-        # Failure modes.
-        with self.assertRaises(TypeError) as cm:
-            ta.set_dtime([1.0, 2.0], 0.5)
-        self.assertTrue(
-            "The two arguments to the set_dtime() method must be of the same type"
-            in str(cm.exception)
-        )
-
-    def test_basic(self):
-        from . import taylor_adaptive_batch, make_vars, t_event_batch, sin
-
-        x, v = make_vars("x", "v")
-
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        ta = taylor_adaptive_batch(
-            sys=sys, state=[[0.0, 0.1], [0.25, 0.26]], t_events=[t_event_batch(v)]
-        )
-
-        self.assertTrue(ta.with_events)
-        self.assertFalse(ta.compact_mode)
-        self.assertFalse(ta.high_accuracy)
-        self.assertEqual(ta.state_vars, [x, v])
-        self.assertEqual(ta.rhs, [v, -9.8 * sin(x)])
-
-        ta = taylor_adaptive_batch(
-            sys=sys,
-            state=[[0.0, 0.1], [0.25, 0.26]],
-            compact_mode=True,
-            high_accuracy=True,
-        )
-
-        self.assertFalse(ta.with_events)
-        self.assertTrue(ta.compact_mode)
-        self.assertTrue(ta.high_accuracy)
-        self.assertFalse(ta.llvm_state.fast_math)
-        self.assertFalse(ta.llvm_state.force_avx512)
-        self.assertEqual(ta.llvm_state.opt_level, 3)
-
-        # Test the custom llvm_state flags.
-        ta = taylor_adaptive_batch(
-            sys=sys,
-            state=[[0.0, 0.1], [0.25, 0.26]],
-            compact_mode=True,
-            high_accuracy=True,
-            force_avx512=True,
-            fast_math=True,
-            opt_level=0,
-        )
-
-        self.assertTrue(ta.llvm_state.fast_math)
-        self.assertTrue(ta.llvm_state.force_avx512)
-        self.assertEqual(ta.llvm_state.opt_level, 0)
-
-    def test_events(self):
-        from . import (
-            nt_event_batch,
-            t_event_batch,
-            make_vars,
-            sin,
-            taylor_adaptive_batch,
-        )
-
-        x, v = make_vars("x", "v")
-
-        # Use a pendulum for testing purposes.
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        def cb0(ta, t, d_sgn, bidx):
-            pass
-
-        ta = taylor_adaptive_batch(
-            sys=sys,
-            state=[[0.0, 0.001], [0.25, 0.2501]],
-            nt_events=[nt_event_batch(v * v - 1e-10, cb0)],
-            t_events=[t_event_batch(v)],
-        )
-
-        self.assertTrue(ta.with_events)
-        self.assertEqual(len(ta.t_events), 1)
-        self.assertEqual(len(ta.nt_events), 1)
-
-        ta.propagate_until([1e9, 1e9])
-        self.assertTrue(all(int(_[0]) == -1 for _ in ta.propagate_res))
-
-        self.assertFalse(ta.te_cooldowns[0][0] is None)
-        self.assertFalse(ta.te_cooldowns[1][0] is None)
-
-        ta.reset_cooldowns(0)
-        self.assertTrue(ta.te_cooldowns[0][0] is None)
-        self.assertFalse(ta.te_cooldowns[1][0] is None)
-
-        ta.reset_cooldowns()
-        self.assertTrue(ta.te_cooldowns[0][0] is None)
-        self.assertTrue(ta.te_cooldowns[1][0] is None)
-
-    def test_s11n(self):
-        from . import (
-            nt_event_batch,
-            t_event_batch,
-            make_vars,
-            sin,
-            taylor_adaptive_batch,
-        )
-        import numpy as np
-        import pickle
-
-        x, v = make_vars("x", "v")
-
-        # Use a pendulum for testing purposes.
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        def cb0(ta, t, d_sgn, bidx):
-            pass
-
-        ta = taylor_adaptive_batch(
-            sys=sys,
-            state=[[0, 0.01], [0.25, 0.26]],
-            nt_events=[nt_event_batch(v * v - 1e-10, cb0)],
-        )
-
-        ta.step()
-        ta.step()
-        ta.step()
-        ta.step()
-
-        ta2 = pickle.loads(pickle.dumps(ta))
-
-        self.assertTrue(np.all(ta.state == ta2.state))
-        self.assertTrue(np.all(ta.time == ta2.time))
-
-        self.assertEqual(len(ta.t_events), len(ta2.t_events))
-        self.assertEqual(len(ta.nt_events), len(ta2.nt_events))
-
-        ta.step()
-        ta2.step()
-
-        self.assertTrue(np.all(ta.state == ta2.state))
-        self.assertTrue(np.all(ta.time == ta2.time))
-
-        ta = taylor_adaptive_batch(sys=sys, state=[[0, 0.01], [0.25, 0.26]], tol=1e-6)
-
-        self.assertEqual(ta.tol, 1e-6)
-
-        # Test dynamic attributes.
-        ta.foo = "hello world"
-        ta = pickle.loads(pickle.dumps(ta))
-        self.assertEqual(ta.foo, "hello world")
-
-        # Try also an integrator with stateful event callback.
-        class cb1:
-            def __init__(self):
-                self.n = 0
-
-            def __call__(self, ta, bool, d_sgn, bidx):
-                self.n = self.n + 1
-
-                return True
-
-        clb = cb1()
-        ta = taylor_adaptive_batch(
-            sys=sys,
-            state=[[0, 0.01], [0.25, 0.26]],
-            t_events=[t_event_batch(v, callback=clb)],
-        )
-
-        self.assertNotEqual(id(clb), id(ta.t_events[0].callback))
-
-        self.assertEqual(ta.t_events[0].callback.n, 0)
-
-        ta.propagate_until([100.0, 100.0])
-
-        ta2 = pickle.loads(pickle.dumps(ta))
-
-        self.assertEqual(ta.t_events[0].callback.n, ta2.t_events[0].callback.n)
-
-    def test_propagate_grid(self):
-        from . import make_vars, taylor_adaptive, taylor_adaptive_batch, sin
-        import numpy as np
-        from copy import deepcopy
-
-        x, v = make_vars("x", "v")
-        eqns = [(x, v), (v, -9.8 * sin(x))]
-
-        x_ic = [0.06, 0.07, 0.08, 0.09]
-        v_ic = [0.025, 0.026, 0.027, 0.028]
-
-        ta = taylor_adaptive_batch(eqns, [x_ic, v_ic])
-
-        # Failure modes.
-        with self.assertRaises(ValueError) as cm:
-            ta.propagate_grid([])
-        self.assertTrue(
-            "Invalid grid passed to the propagate_grid() method of a batch integrator: "
-            "the expected number of dimensions is 2, but the input array has a dimension of 1"
-            in str(cm.exception)
-        )
-
-        with self.assertRaises(ValueError) as cm:
-            ta.propagate_grid([[1, 2], [3, 4]])
-        self.assertTrue(
-            "Invalid grid passed to the propagate_grid() method of a batch integrator: "
-            "the shape must be (n, 4) but the number of columns is 2 instead"
-            in str(cm.exception)
-        )
-
-        # Run a simple scalar/batch comparison.
-        tas = []
-
-        for x0, v0 in zip(x_ic, v_ic):
-            tas.append(taylor_adaptive(eqns, [x0, v0]))
-
-        grid = np.array(
-            [
-                [-0.1, -0.2, -0.3, -0.4],
-                [0.01, 0.02, 0.03, 0.9],
-                [1.0, 1.1, 1.2, 1.3],
-                [11.0, 11.1, 11.2, 11.3],
-            ]
-        )
-
-        bres = ta.propagate_grid(grid)
-
-        sres = [
-            tas[0].propagate_grid(grid[:, 0]),
-            tas[1].propagate_grid(grid[:, 1]),
-            tas[2].propagate_grid(grid[:, 2]),
-            tas[3].propagate_grid(grid[:, 3]),
-        ]
-
-        self.assertTrue(np.max(np.abs(sres[0][4] - bres[:, :, 0]).flatten()) < 1e-14)
-        self.assertTrue(np.max(np.abs(sres[1][4] - bres[:, :, 1]).flatten()) < 1e-14)
-        self.assertTrue(np.max(np.abs(sres[2][4] - bres[:, :, 2]).flatten()) < 1e-14)
-        self.assertTrue(np.max(np.abs(sres[3][4] - bres[:, :, 3]).flatten()) < 1e-14)
-
-        # Test vector/scalar max_delta_t.
-        ta.set_time(0.0)
-        ta.state[:] = [x_ic, v_ic]
-
-        bres = ta.propagate_grid(grid, max_delta_t=[1e-3] * 4)
-        res = deepcopy(ta.propagate_res)
-
-        ta.set_time(0.0)
-        ta.state[:] = [x_ic, v_ic]
-
-        bres2 = ta.propagate_grid(grid, max_delta_t=1e-3)
-
-        self.assertTrue(np.all(bres == bres2))
-        self.assertEqual(ta.propagate_res, res)
-
-        # Test that adding dynattrs to the integrator
-        # object via the propagate callback works.
-        def cb(ta):
-            if hasattr(ta, "counter"):
-                ta.counter += 1
-            else:
-                ta.counter = 0
-
-            return True
-
-        ta.set_time(0.0)
-        ta.propagate_grid(grid, callback=cb)
-
-        self.assertTrue(ta.counter > 0)
-
-        # Test that no copies of the callback are performed.
-        class cb:
-            def __call__(_, ta):
-                self.assertEqual(id(_), _.orig_id)
-
-                return True
-
-        cb_inst = cb()
-        cb_inst.orig_id = id(cb_inst)
-
-        ta.set_time(0.0)
-        ta.propagate_grid(grid, callback=cb_inst)
-
-
 class kepE_test_case(_ut.TestCase):
     def test_expr(self):
         from . import kepE, diff, make_vars, sin, cos, core
@@ -3737,375 +2830,6 @@ def test_basic(self):
         self.assertEqual(get_serialization_backend(), cp)
 
 
-class ensemble_test_case(_ut.TestCase):
-    def test_batch(self):
-        from . import (
-            ensemble_propagate_until_batch,
-            ensemble_propagate_for_batch,
-            ensemble_propagate_grid_batch,
-            make_vars,
-            sin,
-            taylor_adaptive_batch,
-        )
-        import numpy as np
-
-        x, v = make_vars("x", "v")
-
-        # Use a pendulum for testing purposes.
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        algos = ["thread", "process"]
-
-        ta = taylor_adaptive_batch(sys=sys, state=[[0.0] * 4] * 2)
-
-        ics = np.zeros((10, 2, 4))
-        for i in range(10):
-            ics[i, 0] = [
-                0.05 + i / 100,
-                0.051 + i / 100,
-                0.052 + i / 100,
-                0.053 + i / 100.0,
-            ]
-            ics[i, 0] = [
-                0.025 + i / 100,
-                0.026 + i / 100,
-                0.027 + i / 100,
-                0.028 + i / 100.0,
-            ]
-
-        # propagate_until().
-        def gen(ta, idx):
-            ta.set_time(0.0)
-            ta.state[:] = ics[idx]
-
-            return ta
-
-        for algo in algos:
-            if algo == "thread":
-                ret = ensemble_propagate_until_batch(
-                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8
-                )
-            elif algo == "process":
-                ret = ensemble_propagate_until_batch(
-                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, chunksize=3
-                )
-
-            self.assertEqual(len(ret), 10)
-
-            for i in range(10):
-                ta.set_time(0.0)
-                ta.state[:] = ics[i]
-                loc_ret = ta.propagate_until(20.0)
-
-                for j in range(4):
-                    self.assertAlmostEqual(ret[i][0].time[j], 20.0)
-                self.assertTrue(np.all(ta.state == ret[i][0].state))
-                self.assertTrue(ret[i][1] is None)
-                self.assertTrue(np.all(ta.time == ret[i][0].time))
-                self.assertEqual(ta.propagate_res, ret[i][0].propagate_res)
-
-            # Run a test with c_output too.
-            if algo == "thread":
-                ret = ensemble_propagate_until_batch(
-                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, c_output=True
-                )
-            elif algo == "process":
-                ret = ensemble_propagate_until_batch(
-                    ta,
-                    20.0,
-                    10,
-                    gen,
-                    algorithm=algo,
-                    max_workers=8,
-                    chunksize=3,
-                    c_output=True,
-                )
-
-            self.assertEqual(len(ret), 10)
-
-            for i in range(10):
-                ta.set_time(0.0)
-                ta.state[:] = ics[i]
-                loc_ret = ta.propagate_until(20.0, c_output=True)
-
-                for j in range(4):
-                    self.assertAlmostEqual(ret[i][0].time[j], 20.0)
-                self.assertTrue(np.all(ta.state == ret[i][0].state))
-                self.assertFalse(ret[i][1] is None)
-                self.assertTrue(np.all(ta.time == ret[i][0].time))
-                self.assertEqual(ta.propagate_res, ret[i][0].propagate_res)
-
-                self.assertTrue(np.all(loc_ret(5.0) == ret[i][1](5.0)))
-
-        # propagate_for().
-        def gen(ta, idx):
-            ta.set_time(10.0)
-            ta.state[:] = ics[idx]
-
-            return ta
-
-        for algo in algos:
-            if algo == "thread":
-                ret = ensemble_propagate_for_batch(
-                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8
-                )
-            elif algo == "process":
-                ret = ensemble_propagate_for_batch(
-                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, chunksize=3
-                )
-
-            self.assertEqual(len(ret), 10)
-
-            for i in range(10):
-                ta.set_time(10.0)
-                ta.state[:] = ics[i]
-                loc_ret = ta.propagate_for(20.0)
-
-                for j in range(4):
-                    self.assertAlmostEqual(ret[i][0].time[j], 30.0)
-                self.assertTrue(np.all(ta.state == ret[i][0].state))
-                self.assertTrue(ret[i][1] is None)
-                self.assertTrue(np.all(ta.time == ret[i][0].time))
-                self.assertEqual(ta.propagate_res, ret[i][0].propagate_res)
-
-        # propagate_grid().
-        grid = np.linspace(0.0, 20.0, 80)
-
-        splat_grid = np.repeat(grid, 4).reshape(-1, 4)
-
-        def gen(ta, idx):
-            ta.set_time(0.0)
-            ta.state[:] = ics[idx]
-
-            return ta
-
-        for algo in algos:
-            if algo == "thread":
-                ret = ensemble_propagate_grid_batch(
-                    ta, grid, 10, gen, algorithm=algo, max_workers=8
-                )
-            elif algo == "process":
-                ret = ensemble_propagate_grid_batch(
-                    ta, grid, 10, gen, algorithm=algo, max_workers=8, chunksize=3
-                )
-
-            self.assertEqual(len(ret), 10)
-
-            for i in range(10):
-                ta.set_time(0.0)
-                ta.state[:] = ics[i]
-                loc_ret = ta.propagate_grid(splat_grid)
-
-                self.assertTrue(np.all(loc_ret == ret[i][1]))
-
-                for j in range(4):
-                    self.assertAlmostEqual(ret[i][0].time[j], 20.0)
-                self.assertTrue(np.all(ta.state == ret[i][0].state))
-                self.assertTrue(np.all(ta.time == ret[i][0].time))
-                self.assertEqual(ta.propagate_res, ret[i][0].propagate_res)
-
-    def test_scalar(self):
-        from . import (
-            ensemble_propagate_until,
-            ensemble_propagate_for,
-            ensemble_propagate_grid,
-            make_vars,
-            sin,
-            taylor_adaptive,
-            taylor_outcome,
-        )
-        import numpy as np
-
-        x, v = make_vars("x", "v")
-
-        # Use a pendulum for testing purposes.
-        sys = [(x, v), (v, -9.8 * sin(x))]
-
-        algos = ["thread", "process"]
-
-        ta = taylor_adaptive(sys=sys, state=[0.0] * 2)
-
-        ics = np.array([[0.05, 0.025]] * 10)
-        for i in range(10):
-            ics[i] += i / 100.0
-
-        # propagate_until().
-        def gen(ta, idx):
-            ta.time = 0.0
-            ta.state[:] = ics[idx]
-
-            return ta
-
-        for algo in algos:
-            if algo == "thread":
-                ret = ensemble_propagate_until(
-                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8
-                )
-            elif algo == "process":
-                ret = ensemble_propagate_until(
-                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, chunksize=3
-                )
-
-            self.assertEqual(len(ret), 10)
-
-            self.assertTrue(all([_[1] == taylor_outcome.time_limit for _ in ret]))
-
-            for i in range(10):
-                ta.time = 0.0
-                ta.state[:] = ics[i]
-                loc_ret = ta.propagate_until(20.0)
-
-                self.assertAlmostEqual(ret[i][0].time, 20.0)
-                self.assertTrue(np.all(ta.state == ret[i][0].state))
-                self.assertEqual(loc_ret, ret[i][1:])
-                self.assertEqual(ta.time, ret[i][0].time)
-
-            # Run a test with c_output too.
-            if algo == "thread":
-                ret = ensemble_propagate_until(
-                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, c_output=True
-                )
-            elif algo == "process":
-                ret = ensemble_propagate_until(
-                    ta,
-                    20.0,
-                    10,
-                    gen,
-                    algorithm=algo,
-                    max_workers=8,
-                    chunksize=3,
-                    c_output=True,
-                )
-
-            self.assertEqual(len(ret), 10)
-
-            self.assertTrue(all([_[1] == taylor_outcome.time_limit for _ in ret]))
-
-            for i in range(10):
-                ta.time = 0.0
-                ta.state[:] = ics[i]
-                loc_ret = ta.propagate_until(20.0, c_output=True)
-
-                self.assertAlmostEqual(ret[i][0].time, 20.0)
-                self.assertTrue(np.all(ta.state == ret[i][0].state))
-                self.assertEqual(loc_ret[:-1], ret[i][1:-1])
-                self.assertEqual(ta.time, ret[i][0].time)
-
-                self.assertTrue(np.all(loc_ret[-1](5.0) == ret[i][-1](5.0)))
-
-        # propagate_for().
-        def gen(ta, idx):
-            ta.time = 10.0
-            ta.state[:] = ics[idx]
-
-            return ta
-
-        for algo in algos:
-            if algo == "thread":
-                ret = ensemble_propagate_for(
-                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8
-                )
-            elif algo == "process":
-                ret = ensemble_propagate_for(
-                    ta, 20.0, 10, gen, algorithm=algo, max_workers=8, chunksize=3
-                )
-
-            self.assertEqual(len(ret), 10)
-
-            self.assertTrue(all([_[1] == taylor_outcome.time_limit for _ in ret]))
-
-            for i in range(10):
-                ta.time = 10.0
-                ta.state[:] = ics[i]
-                loc_ret = ta.propagate_for(20.0)
-
-                self.assertAlmostEqual(ret[i][0].time, 30.0)
-                self.assertTrue(np.all(ta.state == ret[i][0].state))
-                self.assertEqual(loc_ret, ret[i][1:])
-                self.assertEqual(ta.time, ret[i][0].time)
-
-        # propagate_grid().
-        grid = np.linspace(0.0, 20.0, 80)
-
-        def gen(ta, idx):
-            ta.time = 0.0
-            ta.state[:] = ics[idx]
-
-            return ta
-
-        for algo in algos:
-            if algo == "thread":
-                ret = ensemble_propagate_grid(
-                    ta, grid, 10, gen, algorithm=algo, max_workers=8
-                )
-            elif algo == "process":
-                ret = ensemble_propagate_grid(
-                    ta, grid, 10, gen, algorithm=algo, max_workers=8, chunksize=3
-                )
-
-            self.assertEqual(len(ret), 10)
-
-            self.assertTrue(all([_[1] == taylor_outcome.time_limit for _ in ret]))
-
-            for i in range(10):
-                ta.time = 0.0
-                ta.state[:] = ics[i]
-                loc_ret = ta.propagate_grid(grid)
-
-                self.assertAlmostEqual(ret[i][0].time, 20.0)
-                self.assertTrue(np.all(ta.state == ret[i][0].state))
-                self.assertEqual(loc_ret[:-1], ret[i][1:-1])
-                self.assertTrue(np.all(loc_ret[-1] == ret[i][-1]))
-                self.assertEqual(ta.time, ret[i][0].time)
-
-        # Error handling.
-        with self.assertRaises(TypeError) as cm:
-            ensemble_propagate_until(ta, 20.0, "a", gen)
-        self.assertTrue(
-            "The n_iter parameter must be an integer, but an object of type"
-            in str(cm.exception)
-        )
-
-        with self.assertRaises(ValueError) as cm:
-            ensemble_propagate_until(ta, 20.0, -1, gen)
-        self.assertTrue(
-            "The n_iter parameter must be non-negative" in str(cm.exception)
-        )
-
-        with self.assertRaises(TypeError) as cm:
-            ensemble_propagate_until(ta, [20.0], 10, gen)
-        self.assertTrue(
-            "Cannot perform an ensemble propagate_until/for(): the final epoch/time interval must be a scalar, not an iterable object"
-            in str(cm.exception)
-        )
-
-        with self.assertRaises(TypeError) as cm:
-            ensemble_propagate_for(ta, [20.0], 10, gen)
-        self.assertTrue(
-            "Cannot perform an ensemble propagate_until/for(): the final epoch/time interval must be a scalar, not an iterable object"
-            in str(cm.exception)
-        )
-
-        with self.assertRaises(ValueError) as cm:
-            ensemble_propagate_grid(ta, [[20.0, 20.0]], 10, gen)
-        self.assertTrue(
-            "Cannot perform an ensemble propagate_grid(): the input time grid must be one-dimensional, but instead it has 2 dimensions"
-            in str(cm.exception)
-        )
-
-        with self.assertRaises(TypeError) as cm:
-            ensemble_propagate_until(ta, 20.0, 10, gen, max_delta_t=[10])
-        self.assertTrue(
-            'Cannot perform an ensemble propagate_until/for/grid(): the "max_delta_t" argument must be a scalar, not an iterable object'
-            in str(cm.exception)
-        )
-
-        # NOTE: check that the chunksize option is not recognised
-        # in threaded mode.
-        with self.assertRaises(TypeError) as cm:
-            ensemble_propagate_until(ta, 20.0, 10, gen, chunksize=1)
-
-
 def run_test_suite():
     from . import (
         taylor_adaptive,
@@ -4116,6 +2840,9 @@ def run_test_suite():
         _test_model,
         _test_expression,
         _test_dtens,
+        _test_scalar_integrator,
+        _test_batch_integrator,
+        _test_ensemble,
     )
     import numpy as np
     from .model import nbody
@@ -4128,13 +2855,15 @@ def run_test_suite():
     retval = 0
 
     suite = _ut.TestLoader().loadTestsFromTestCase(taylor_add_jet_test_case)
+    suite.addTest(_ut.makeSuite(_test_scalar_integrator.scalar_integrator_test_case))
+    suite.addTest(_ut.makeSuite(_test_batch_integrator.batch_integrator_test_case))
     suite.addTest(_ut.makeSuite(_test_dtens.dtens_test_case))
     suite.addTest(_ut.makeSuite(_test_mp.mp_test_case))
     suite.addTest(_ut.makeSuite(_test_model.model_test_case))
     suite.addTest(_ut.makeSuite(_test_real.real_test_case))
     suite.addTest(_ut.makeSuite(_test_real128.real128_test_case))
     suite.addTest(_ut.makeSuite(_test_cfunc.cfunc_test_case))
-    suite.addTest(_ut.makeSuite(ensemble_test_case))
+    suite.addTest(_ut.makeSuite(_test_ensemble.ensemble_test_case))
     suite.addTest(_ut.makeSuite(s11n_backend_test_case))
     suite.addTest(_ut.makeSuite(recommended_simd_size_test_case))
     suite.addTest(_ut.makeSuite(c_output_test_case))
@@ -4142,8 +2871,6 @@ def run_test_suite():
     suite.addTest(_ut.makeSuite(llvm_state_test_case))
     suite.addTest(_ut.makeSuite(event_classes_test_case))
     suite.addTest(_ut.makeSuite(event_detection_test_case))
-    suite.addTest(_ut.makeSuite(batch_integrator_test_case))
-    suite.addTest(_ut.makeSuite(scalar_integrator_test_case))
     suite.addTest(_ut.makeSuite(kepE_test_case))
     suite.addTest(_ut.makeSuite(sympy_test_case))