Repository: myokit/myokit (language: python)

Issue:
US spelling in API
Not sure if I ever decided

-  neighbour/bor
- colour/or
- ise/ize

*Update* US is more common, especially "color", so going with that.

- [x] colour --> color
- [x] neighbour --> neighbor
- [x] initialise --> initialize
- [x] sanitise --> sanitize
- [x] *alise --> *alize
- [x] fibre --> fiber
- [x] behaviour --> behavior
- [x] centre --> center
- [x] favour --> favor





Discussion / hints:
Usually I'd say in order of preference:
- don't break existing stuff unnecessarily (but can always throw 'deprecated' warnings I guess)
- consitency either way is nice
- you're right that CS & the user base may be more American. On the other hand we're a UK-based team....

~UK spelling it is!~
`grep "neighbor" ./myokit/ -ir` --> nothing
`grep "color" ./myokit/ -ir` --> lots
`grep "[^s]ize" ./myokit/ -ir` --> lots

Hmmmmmm





Fix patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 97fa810ec..1365b45c0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,16 +23,17 @@ This page lists the main changes made to Myokit in each release.
   - [#962](https://github.com/myokit/myokit/pull/962) The DataLogViewer only supports Matlab file loading if SciPy is installed.
   - [#975](https://github.com/myokit/myokit/pull/975) Global parameters in imported SBML documents are now placed in a component named `global` instead of `myokit`.
 - Deprecated
-  - [#918](https://github.com/myokit/myokit/pull/918) `Model.state` is deprecated in favour of `Model.initial_values`.
-  - [#918](https://github.com/myokit/myokit/pull/918) `Model.set_state` is deprecated in favour of `Model.set_initial_values`.
+  - [#918](https://github.com/myokit/myokit/pull/918) `Model.state` is deprecated in favor of `Model.initial_values`.
+  - [#918](https://github.com/myokit/myokit/pull/918) `Model.set_state` is deprecated in favor of `Model.set_initial_values`.
   - [#918](https://github.com/myokit/myokit/pull/918) `Model.inits` is deprecated.
-  - [#918](https://github.com/myokit/myokit/pull/918) `Variable.state_value` is deprecated in favour of `Variable.initial_value`.
-  - [#918](https://github.com/myokit/myokit/pull/918) `Variable.set_state_value` is deprecated in favour of `Variable.set_initial_value`.
+  - [#918](https://github.com/myokit/myokit/pull/918) `Variable.state_value` is deprecated in favor of `Variable.initial_value`.
+  - [#918](https://github.com/myokit/myokit/pull/918) `Variable.set_state_value` is deprecated in favor of `Variable.set_initial_value`.
   - [#918](https://github.com/myokit/myokit/pull/918) `Model.save_state` and `Model.load_state` are deprecated.
-  - [#918](https://github.com/myokit/myokit/pull/918) The `Variable.promote` keyword argument `state_value` is deprecated in favour of `initial_value`.
-  - [#947](https://github.com/myokit/myokit/pull/947) `Simulation.set_fixed_form_protocol` is deprecated in favour of using `Simulation.set_protocol` with a `TimeSeriesProtocol`
+  - [#918](https://github.com/myokit/myokit/pull/918) The `Variable.promote` keyword argument `state_value` is deprecated in favor of `initial_value`.
+  - [#947](https://github.com/myokit/myokit/pull/947) `Simulation.set_fixed_form_protocol` is deprecated in favor of using `Simulation.set_protocol` with a `TimeSeriesProtocol`
   - [#962](https://github.com/myokit/myokit/pull/962) The method `DataLog.regularize` is deprecated.
-  - [#974](https://github.com/myokit/myokit/pull/974) `Variable.indice` is deprecated in favour of `Variable.index`.
+  - [#974](https://github.com/myokit/myokit/pull/974) `Variable.indice` is deprecated in favor of `Variable.index`.
+  - [#976](https://github.com/myokit/myokit/pull/976) `SimulationOpenCL.neighbours` is deprecated in favor of `SimulationOpenCL.neighbors`.
 - Removed
   - [#898](https://github.com/myokit/myokit/pull/899) `NonLiteralValueError` is now no longer raised by Myokit and so has been removed.
   - [#921](https://github.com/myokit/myokit/pull/921) Removed deprecated `LegacySimulation` class.
@@ -188,14 +189,14 @@ This page lists the main changes made to Myokit in each release.
   - [#728](https://github.com/MichaelClerx/myokit/pull/728) The `LegacySimulation` class no longer suppresses CVODE warnings but passes them on to the `warnings` module (backported from new `Simulation` class).
   - [#789](https://github.com/MichaelClerx/myokit/pull/789) The method `myokit.DataLog.save_csv()` now stores the keys using natural sort order (time is still the first field, if present).
 - Deprecated
-  - [#595](https://github.com/MichaelClerx/myokit/pull/595) The classes `myokit.PSimulation` and `myokit.ICSimulation` have been deprecated in favour of the new `Simulation` class.
-  - [#735](https://github.com/MichaelClerx/myokit/pull/735) The class `myokit.Benchmarker` is deprecated in favour of `myokit.tools.Benchmarker`.
+  - [#595](https://github.com/MichaelClerx/myokit/pull/595) The classes `myokit.PSimulation` and `myokit.ICSimulation` have been deprecated in favor of the new `Simulation` class.
+  - [#735](https://github.com/MichaelClerx/myokit/pull/735) The class `myokit.Benchmarker` is deprecated in favor of `myokit.tools.Benchmarker`.
   - [#735](https://github.com/MichaelClerx/myokit/pull/735) The method `myokit.format_float_dict` is deprecated and will be removed in future versions.
-  - [#735](https://github.com/MichaelClerx/myokit/pull/735) The method `myokit.format_path` is deprecated in favour of `myokit.tools.format_path`.
-  - [#735](https://github.com/MichaelClerx/myokit/pull/735) The method `myokit.strfloat` is deprecated in favour of `myokit.float.str`.
+  - [#735](https://github.com/MichaelClerx/myokit/pull/735) The method `myokit.format_path` is deprecated in favor of `myokit.tools.format_path`.
+  - [#735](https://github.com/MichaelClerx/myokit/pull/735) The method `myokit.strfloat` is deprecated in favor of `myokit.float.str`.
   - [#758](https://github.com/MichaelClerx/myokit/pull/758) The class `myokit.FiberTissueSimulation` is deprecated and will be removed in future versions.
-  - [#776](https://github.com/MichaelClerx/myokit/pull/776) The method `OpenCLSimulation.calculate_conductance` is deprecated in favour of the new method `calculate_conductance`, which takes slightly different parameters.
-  - [#787](https://github.com/MichaelClerx/myokit/pull/787) The method `myokit.Model.eval_state_derivatives` is deprecated in favour of `myokit.Model.evaluate_derivatives`.
+  - [#776](https://github.com/MichaelClerx/myokit/pull/776) The method `OpenCLSimulation.calculate_conductance` is deprecated in favor of the new method `calculate_conductance`, which takes slightly different parameters.
+  - [#787](https://github.com/MichaelClerx/myokit/pull/787) The method `myokit.Model.eval_state_derivatives` is deprecated in favor of `myokit.Model.evaluate_derivatives`.
 - Removed
   - [#683](https://github.com/MichaelClerx/myokit/pull/683) No longer testing on Python 2.7.6 on linux (still testing latest 2.7). No longer testing any Python 2.7 on Windows.
   - [#728](https://github.com/MichaelClerx/myokit/pull/728) The classes `myokit.PyCapture` and `myokit.SubCapture` have been replaced by a single context manager `myokit.tools.capture`.
@@ -253,8 +254,8 @@ This page lists the main changes made to Myokit in each release.
   - [#664](https://github.com/MichaelClerx/myokit/pull/664) EasyML export now has consistently ordered output when re-run.
   - [#664](https://github.com/MichaelClerx/myokit/pull/664) EasyML expression writer now uses `expm1` where possible.
 - Deprecated
-  - [#622](https://github.com/MichaelClerx/myokit/pull/622) `SimulationOpenCL.is2d()` was deprecated in favour of `SimulationOpenCL.is_2d()`.
-  - [#632](https://github.com/MichaelClerx/myokit/pull/632) `DataBlock1d.from_DataLog` and `DataBlock2d.from_DataLog` have both been deprecated, in favour of new `from_log` methods.
+  - [#622](https://github.com/MichaelClerx/myokit/pull/622) `SimulationOpenCL.is2d()` was deprecated in favor of `SimulationOpenCL.is_2d()`.
+  - [#632](https://github.com/MichaelClerx/myokit/pull/632) `DataBlock1d.from_DataLog` and `DataBlock2d.from_DataLog` have both been deprecated, in favor of new `from_log` methods.
 - Fixed
   - [#650](https://github.com/MichaelClerx/myokit/pull/650) Fix to `myokit.lib.plots.cumulative_current` for normalisation in areas with zero current.
   - [#603](https://github.com/MichaelClerx/myokit/pull/603) Improved handling of types (ints resulting from logical operators) in `OpenCLSimulation`.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index d837ae790..14d8e310d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -162,9 +162,13 @@ Avoid abbreviations when possible without making names overly long.
 Class names are CamelCase, and start with an upper case letter, for example `SuperDuperSimulation`.
 Method and variable names are lower case, and use underscores for word separation, for example `x` or `iteration_count`.
 
+### Spelling
+
+Because most libraries do, Myokit uses American spelling (e.g. "color", "fiber", "normalize").
+
 ### Python 2 and 3
 
-Myokit runs in Python 2.7+ and 3.5+.
+Myokit runs in Python 2.7+ and 3.7+.
 All new code should be written [to work on both](http://python-future.org/compatible_idioms.html).
 
 ## Dependencies and reusing code
diff --git a/docs/source/api_simulations/index.rst b/docs/source/api_simulations/index.rst
index 8b1eef5a9..1ae82011d 100644
--- a/docs/source/api_simulations/index.rst
+++ b/docs/source/api_simulations/index.rst
@@ -21,7 +21,7 @@ specialized dict type can be stored to disk using
 or two-dimensional logs often take the shape of a rectangular grid. While the
 :class:`DataLog` class is built for maximum flexibility and allows irregular
 shapes, it can often be useful to exploit the rectangular grid shape of the
-data. For these cases, the data logs can be converted to specialised structures
+data. For these cases, the data logs can be converted to specialized structures
 called :class:`DataBlock1d` and :class:`DataBlock2d`.
 
 A few specialized classes are included in the simulations package. The
diff --git a/docs/source/syntax/model.rst b/docs/source/syntax/model.rst
index 8a2a36e7a..08c8e97bf 100644
--- a/docs/source/syntax/model.rst
+++ b/docs/source/syntax/model.rst
@@ -475,7 +475,7 @@ Interfacing with the outside world
 In many cases, not all variables of interest are contained within the model.
 For example if a simulation engine is used to drive the model this engine may
 provide a variable ``time``. Other examples of external variables include a
-pacing or driving variable or an input current derived from neighbouring cells.
+pacing or driving variable or an input current derived from neighboring cells.
 
 The ``mmt`` syntax allows variables to be *bound* to an external value using
 the ``bind`` keyword::
diff --git a/myokit/__init__.py b/myokit/__init__.py
index 808ca7f89..322f4b7b5 100644
--- a/myokit/__init__.py
+++ b/myokit/__init__.py
@@ -287,7 +287,7 @@
 TIME_FORMAT = '%H:%M:%S'
 
 #
-# GUI: Favour PySide or PyQt
+# GUI: Favor PySide or PyQt
 #
 FORCE_PYQT5 = False
 FORCE_PYQT4 = False
diff --git a/myokit/_aux.py b/myokit/_aux.py
index 4936c5945..eaa7273c5 100644
--- a/myokit/_aux.py
+++ b/myokit/_aux.py
@@ -713,7 +713,7 @@ def step(model, initial=None, reference=None, ignore_errors=False):
         if warnings > 0:
             log.append('Found (' + str(warnings) + ') small mismatches.')
 
-    # Finalise and return
+    # Finalize and return
     log.append('-' * line_width)
     return '\n'.join(log)
 
diff --git a/myokit/_datalog.py b/myokit/_datalog.py
index fd82a5746..115702b48 100644
--- a/myokit/_datalog.py
+++ b/myokit/_datalog.py
@@ -1136,7 +1136,7 @@ def split_periodic(self, period, adjust=False, closed_intervals=True):
 
         By default, the returned intervals are *closed*, so both the left and
         right endpoint are included (if present in the data). This may involve
-        the duplication of some data points. To disable this behaviour and
+        the duplication of some data points. To disable this behavior and
         return half-closed endpoints (containing only the left point), set
         ``closed_intervals`` to ``False``.
         """
diff --git a/myokit/_expressions.py b/myokit/_expressions.py
index 42fdac295..9b520ac0b 100644
--- a/myokit/_expressions.py
+++ b/myokit/_expressions.py
@@ -1880,7 +1880,7 @@ def _diff(self, lhs, idstates):
         #
         # Alternatively, a // b = floor(a / b).
         #
-        # Here we ignore the discontinuities in favour of a left or right
+        # Here we ignore the discontinuities in favor of a left or right
         # derivative, and simply return zero for all points.
         return None
 
diff --git a/myokit/_model_api.py b/myokit/_model_api.py
index 8ff79e3f8..c93616d53 100644
--- a/myokit/_model_api.py
+++ b/myokit/_model_api.py
@@ -785,7 +785,7 @@ class Model(ObjectWithMeta, VarProvider):
     For consistency with components, variables, and expressions, models cannot
     be compared with ``==`` (which will only return ``True`` if both operands
     are the same object). Checking if models are the same in other senses can
-    be done with :meth:`is_similar`. Models can be serialised with ``pickle``.
+    be done with :meth:`is_similar`. Models can be serialized with ``pickle``.
     """
 
     def __init__(self, name=None):
@@ -2202,7 +2202,7 @@ def map_component_dependencies(
         not ``[B,C]``.
 
         By default, dependencies on state variables' current values are
-        omitted. This behaviour can be changed by setting ``omit_states`` to
+        omitted. This behavior can be changed by setting ``omit_states`` to
         ``False``.
 
         To omit all dependencies on constants, set ``omit_constants`` to
@@ -2382,7 +2382,7 @@ def map_deep_dependencies(
         dependencies will be added to the dependency lists of their parents.
 
         By default, dependencies on state variables' current values are
-        omitted. This behaviour can be changed by setting ``omit_states`` to
+        omitted. This behavior can be changed by setting ``omit_states`` to
         ``False``.
 
         In case of a dependency such as::
@@ -2526,7 +2526,7 @@ def map_shallow_dependencies(
         dependencies will be added to the dependency lists of their parents.
 
         By default, dependencies on state variables' current values are
-        omitted. This behaviour can be changed by setting ``omit_states`` to
+        omitted. This behavior can be changed by setting ``omit_states`` to
         ``False``. Dependencies on constants are included by default, but this
         can be changed by setting ``omit_constants`` to ``True``.
         """
diff --git a/myokit/_progress.py b/myokit/_progress.py
index 7c72ebb79..251241911 100644
--- a/myokit/_progress.py
+++ b/myokit/_progress.py
@@ -21,7 +21,7 @@ class ProgressReporter(object):
     pass in an object implementing this interface. The simulation will use this
     object to report on its progress.
 
-    Note that progress reporters should be re-usable, but the behaviour when
+    Note that progress reporters should be re-usable, but the behavior when
     making calls to a reporter from two different processes (either through
     multi-threading/multi-processing or jobs nested within jobs) is undefined.
 
diff --git a/myokit/_protocol.py b/myokit/_protocol.py
index d3ed11428..48eb03036 100644
--- a/myokit/_protocol.py
+++ b/myokit/_protocol.py
@@ -45,7 +45,7 @@ class Protocol(object):
     is not.
 
     Protocols can be compared with ``==``, which will check if the :meth:`code`
-    for both protocols is the same. Protocols can be serialised with
+    for both protocols is the same. Protocols can be serialized with
     ``pickle``.
     """
     def __init__(self):
@@ -865,7 +865,7 @@ class TimeSeriesProtocol(object):
 
     Protocols can be compared with ``==``, which will check if the sequence of
     time value pairs is the same, and the interpolation method is the same.
-    Protocols can be serialised with ``pickle``.
+    Protocols can be serialized with ``pickle``.
 
     """
 
diff --git a/myokit/_sim/cable.c b/myokit/_sim/cable.c
index c4e345ea6..7f24d11cb 100644
--- a/myokit/_sim/cable.c
+++ b/myokit/_sim/cable.c
@@ -279,7 +279,7 @@ py_sim_clean()
 }
 
 /*
- * Initialise a run
+ * Initialize a run
  */
 static PyObject*
 sim_init(PyObject *self, PyObject *args)
diff --git a/myokit/_sim/cable.py b/myokit/_sim/cable.py
index 4eec6032f..21f237cdf 100644
--- a/myokit/_sim/cable.py
+++ b/myokit/_sim/cable.py
@@ -39,7 +39,7 @@ class Simulation1d(myokit.CModule):
     ``pace``
         The pacing level, this is set if a protocol was passed in.
     ``diffusion_current``
-        The current flowing from the cell to its neighbours. This will be
+        The current flowing from the cell to its neighbors. This will be
         positive when the cell is acting as a source, negative when it is
         acting as a sink.
 
@@ -77,7 +77,7 @@ class Simulation1d(myokit.CModule):
 
         i = sum[g * (V - V_j)]
 
-    Where the sum is taken over all neighbouring cells j (see [1]).
+    Where the sum is taken over all neighboring cells j (see [1]).
 
     The resulting ODE system is solved using a forward Euler (FE) method with
     fixed step sizes. Smaller step sizes lead to more accurate results, and it
diff --git a/myokit/_sim/cmodel.h b/myokit/_sim/cmodel.h
index a94eaa197..2ecf824fa 100644
--- a/myokit/_sim/cmodel.h
+++ b/myokit/_sim/cmodel.h
@@ -154,7 +154,7 @@ will be a myokit.DataLog.
 
 Methods:
 
-Model_InitialiseLogging(Model model, PyObject* log_dict)
+Model_InitializeLogging(Model model, PyObject* log_dict)
     Sets up logging for all variables used as keys in log_dict (assuming fully
     qualified names). Will raise an error if the dict contains keys that do not
     correspond to model variables. The values in the dict should implement the
@@ -164,9 +164,9 @@ Model_Log(model)
     If logging has been set up, this will log the current values of variables
     to the sequences in the log dict.
 
-Model_DeInitialiseLogging(model)
-    De-initialises logging. This only needs to be called if logging needs to be
-    set up differently, i.e. before a new call to Model_InitialiseLogging.
+Model_DeInitializeLogging(model)
+    De-initializes logging. This only needs to be called if logging needs to be
+    set up differently, i.e. before a new call to Model_InitializeLogging.
 
 Logging sensitivities
 =====================
@@ -208,8 +208,8 @@ typedef int Model_Flag;
 /* General */
 #define Model_INVALID_MODEL                 -100
 /* Logging */
-#define Model_LOGGING_ALREADY_INITIALISED   -200
-#define Model_LOGGING_NOT_INITIALISED       -201
+#define Model_LOGGING_ALREADY_INITIALIZED   -200
+#define Model_LOGGING_NOT_INITIALIZED       -201
 #define Model_UNKNOWN_VARIABLES_IN_LOG      -202
 #define Model_LOG_APPEND_FAILED             -203
 /* Logging sensitivities */
@@ -243,11 +243,11 @@ Model_SetPyErr(Model_Flag flag)
         PyErr_SetString(PyExc_Exception, "CModel error: Invalid model pointer provided.");
         break;
     /* Logging */
-    case Model_LOGGING_ALREADY_INITIALISED:
-        PyErr_SetString(PyExc_Exception, "CModel error: Logging initialised twice.");
+    case Model_LOGGING_ALREADY_INITIALIZED:
+        PyErr_SetString(PyExc_Exception, "CModel error: Logging initialized twice.");
         break;
-    case Model_LOGGING_NOT_INITIALISED:
-        PyErr_SetString(PyExc_Exception, "CModel error: Logging not initialised.");
+    case Model_LOGGING_NOT_INITIALIZED:
+        PyErr_SetString(PyExc_Exception, "CModel error: Logging not initialized.");
         break;
     case Model_UNKNOWN_VARIABLES_IN_LOG:
         PyErr_SetString(PyExc_Exception, "CModel error: Unknown variables found in logging dictionary.");
@@ -334,8 +334,8 @@ struct Model_Memory {
     int ns_intermediary;
     realtype* s_intermediary;
 
-    /* Logging initialised? */
-    int logging_initialised;
+    /* Logging initialized? */
+    int logging_initialized;
 
     /* Which variables are we logging? */
     int logging_states;
@@ -946,23 +946,23 @@ Model__AddVariableToLog(
 }
 
 /*
- * Initialises logging, using the given dict. An error is returned if logging
- * is already initialised.
+ * Initializes logging, using the given dict. An error is returned if logging
+ * is already initialized.
  *
  * Arguments
- *  model : The model whose logging system to initialise.
+ *  model : The model whose logging system to initialize.
  *  log_dict : A Python dict mapping fully qualified variable names to sequence
  *             objects to log in.
  *
  * Returns a model flag
  */
 Model_Flag
-Model_InitialiseLogging(Model model, PyObject* log_dict)
+Model_InitializeLogging(Model model, PyObject* log_dict)
 {
     int i, j;
 
     if (model == NULL) return Model_INVALID_MODEL;
-    if (model->logging_initialised) return Model_LOGGING_ALREADY_INITIALISED;
+    if (model->logging_initialized) return Model_LOGGING_ALREADY_INITIALIZED;
 
     /* Number of variables to log */
     model->n_logged_variables = (int)PyDict_Size(log_dict);
@@ -1012,24 +1012,24 @@ for var in model.variables(deep=True, state=False, bound=False, const=False):
     }
 
     /* All done! */
-    model->logging_initialised = 1;
+    model->logging_initialized = 1;
     return Model_OK;
 }
 
 /*
- * De-initialises logging, undoing the effects of Model_InitialiseLogging() and
- * allowing logging to be initialised again.
+ * De-initializes logging, undoing the effects of Model_InitializeLogging() and
+ * allowing logging to be initialized again.
  *
  * Arguments
- *  model : The model whos logging to deinitialise.
+ *  model : The model whos logging to deinitialize.
  *
  * Returns a model flag.
  */
 Model_Flag
-Model_DeInitialiseLogging(Model model)
+Model_DeInitializeLogging(Model model)
 {
     if (model == NULL) return Model_INVALID_MODEL;
-    if (!model->logging_initialised) return Model_LOGGING_NOT_INITIALISED;
+    if (!model->logging_initialized) return Model_LOGGING_NOT_INITIALIZED;
 
     /* Free memory */
     if (model->_log_vars != NULL) {
@@ -1042,7 +1042,7 @@ Model_DeInitialiseLogging(Model model)
     }
 
     /* Reset */
-    model->logging_initialised = 0;
+    model->logging_initialized = 0;
     model->n_logged_variables = 0;
     model->logging_states = 0;
     model->logging_derivatives = 0;
@@ -1054,7 +1054,7 @@ Model_DeInitialiseLogging(Model model)
 
 /*
  * Logs the current state of the model to the logging dict passed in to
- * Model_InitialiseLogging.
+ * Model_InitializeLogging.
  *
  * Note: This method does not update the state in any way, e.g. to make sure
  * that what is logged is sensible.
@@ -1071,7 +1071,7 @@ Model_Log(Model model)
     PyObject *val, *ret;
 
     if (model == NULL) return Model_INVALID_MODEL;
-    if (!model->logging_initialised) return Model_LOGGING_NOT_INITIALISED;
+    if (!model->logging_initialized) return Model_LOGGING_NOT_INITIALIZED;
 
     for (i=0; i<model->n_logged_variables; i++) {
         val = PyFloat_FromDouble(*(model->_log_vars[i]));
@@ -1232,7 +1232,7 @@ for i, expr in enumerate(s_independents):
      */
 
     /* Logging configured? */
-    model->logging_initialised = 0;
+    model->logging_initialized = 0;
     model->n_logged_variables = 0;
 
     /* Logged variables and logged types */
@@ -1295,7 +1295,7 @@ for var in model.states():
     #endif
 
     /*
-     * Finalise
+     * Finalize
      */
 
     /* Set flag to indicate success */
diff --git a/myokit/_sim/cvodessim.c b/myokit/_sim/cvodessim.c
index 9b855b0f3..f74425e3d 100644
--- a/myokit/_sim/cvodessim.c
+++ b/myokit/_sim/cvodessim.c
@@ -185,7 +185,7 @@ ErrorHandler(int error_code, const char *module, const char *function,
  * Initialisation status.
  * Proper sequence is init(), repeated step() calls till finished, then clean.
  */
-int initialised = 0; /* Has the simulation been initialised */
+int initialized = 0; /* Has the simulation been initialized */
 
 /*
  * Model
@@ -436,7 +436,7 @@ rf_function(realtype t, N_Vector y, realtype *gout, void *user_data)
 PyObject*
 sim_clean(void)
 {
-    if (initialised) {
+    if (initialized) {
         #ifdef MYOKIT_DEBUG_PROFILING
         benchmarker_print("CP Entered sim_clean.");
         #elif defined MYOKIT_DEBUG_MESSAGES
@@ -495,7 +495,7 @@ sim_clean(void)
         Py_XDECREF(benchmarker_time_str); benchmarker_time_str = NULL;
 
         /* Deinitialisation complete */
-        initialised = 0;
+        initialized = 0;
     }
 
     /* Return 0, allowing the construct
@@ -533,7 +533,7 @@ py_sim_clean(PyObject *self, PyObject *args)
 }
 
 /*
- * Initialise a run.
+ * Initialize a run.
  * Called by the Python code's run(), followed by several calls to sim_step().
  */
 PyObject*
@@ -567,9 +567,9 @@ sim_init(PyObject *self, PyObject *args)
     PyObject *val;
     PyObject *ret;
 
-    /* Check if already initialised */
-    if (initialised) {
-        PyErr_SetString(PyExc_Exception, "Simulation already initialised.");
+    /* Check if already initialized */
+    if (initialized) {
+        PyErr_SetString(PyExc_Exception, "Simulation already initialized.");
         return 0;
     }
 
@@ -636,8 +636,8 @@ sim_init(PyObject *self, PyObject *args)
         return 0;
     }
 
-    /* Now officialy initialised */
-    initialised = 1;
+    /* Now officialy initialized */
+    initialized = 1;
 
     /*************************************************************************
     From this point on, no more direct returning! Use sim_clean()
@@ -1043,7 +1043,7 @@ sim_init(PyObject *self, PyObject *args)
         flag_cvode = CVodeSetErrHandlerFn(cvode_mem, ErrorHandler, NULL);
         if (check_cvode_flag(&flag_cvode, "CVodeInit", 1)) return sim_clean();
 
-        /* Initialise solver memory, specify the rhs */
+        /* Initialize solver memory, specify the rhs */
         flag_cvode = CVodeInit(cvode_mem, rhs, t, y);
         if (check_cvode_flag(&flag_cvode, "CVodeInit", 1)) return sim_clean();
 
@@ -1102,7 +1102,7 @@ sim_init(PyObject *self, PyObject *args)
         #endif
 
         #ifdef MYOKIT_DEBUG_PROFILING
-        benchmarker_print("CP CVODES solver initialised.");
+        benchmarker_print("CP CVODES solver initialized.");
         #endif
 
         /* Activate forward sensitivity computations */
@@ -1126,7 +1126,7 @@ sim_init(PyObject *self, PyObject *args)
             if (check_cvode_flag(&flag_cvode, "CVodeSensEEtolerances", 1)) return sim_clean();
 
             #ifdef MYOKIT_DEBUG_PROFILING
-            benchmarker_print("CP CVODES sensitivity methods initialised.");
+            benchmarker_print("CP CVODES sensitivity methods initialized.");
             #endif
         }
     }
@@ -1146,7 +1146,7 @@ sim_init(PyObject *self, PyObject *args)
         rf_direction = (int*)malloc(sizeof(int));
 
         #ifdef MYOKIT_DEBUG_PROFILING
-        benchmarker_print("CP CVODES root-finding initialised.");
+        benchmarker_print("CP CVODES root-finding initialized.");
         #endif
     }
 
@@ -1162,10 +1162,10 @@ sim_init(PyObject *self, PyObject *args)
     }
 
     /* Set up logging */
-    flag_model = Model_InitialiseLogging(model, log_dict);
+    flag_model = Model_InitializeLogging(model, log_dict);
     if (flag_model != Model_OK) { Model_SetPyErr(flag_model); return sim_clean(); }
     #ifdef MYOKIT_DEBUG_PROFILING
-    benchmarker_print("CP Logging initialised.");
+    benchmarker_print("CP Logging initialized.");
     #endif
 
     /* Check logging list for sensitivities */
@@ -1262,7 +1262,7 @@ sim_init(PyObject *self, PyObject *args)
     }
 
     #ifdef MYOKIT_DEBUG_PROFILING
-    benchmarker_print("CP Logging times and strategy initialised.");
+    benchmarker_print("CP Logging times and strategy initialized.");
     #endif
 
     /*
diff --git a/myokit/_sim/cvodessim.py b/myokit/_sim/cvodessim.py
index 03670a94a..189494242 100644
--- a/myokit/_sim/cvodessim.py
+++ b/myokit/_sim/cvodessim.py
@@ -85,7 +85,7 @@ class Simulation(myokit.CModule):
         determined using the protocol passed into the Simulation.
     ``evaluations``
         This input provides the number of rhs evaluations used at each point in
-        time and can be used to gain some insight into the solver's behaviour.
+        time and can be used to gain some insight into the solver's behavior.
     ``realtime``
         This input provides the elapsed system time at each logged point.
 
@@ -99,8 +99,8 @@ class Simulation(myokit.CModule):
 
     Each time a simulation is created, a C module is compiled, imported, and
     deleted in the background. This means that part of a ``Simulation`` object
-    is a reference to an imported C extension, and cannot be serialised. When
-    using ``pickle`` to serialise the simulation, this compiled part is not
+    is a reference to an imported C extension, and cannot be serialized. When
+    using ``pickle`` to serialize the simulation, this compiled part is not
     stored. Instead, when the pickled simulation is read from disk the
     compilation is repeated. Unpickling simulations also restores their state:
     variables such as model state, simulation time, and tolerance are preserved
@@ -303,7 +303,7 @@ def _store_build(self, path, d_build, name):
             if self._sensitivities:
                 sens_arg = [[x.code() for x in y] for y in self._sensitivities]
 
-            # Store serialised name and constructor args
+            # Store serialized name and constructor args
             fname = os.path.join(d_build, '_simulation.pickle')
             import pickle
             with open(fname, 'wb') as f:
@@ -350,7 +350,7 @@ def from_path(path):
             with zipfile.ZipFile(path, 'r', zipfile.ZIP_DEFLATED) as f:
                 f.extractall(d_build)
 
-            # Load serialised name and constructor args
+            # Load serialized name and constructor args
             fname = os.path.join(d_build, '_simulation.pickle')
             import pickle
             with open(fname, 'rb') as f:
diff --git a/myokit/_sim/fiber_tissue.py b/myokit/_sim/fiber_tissue.py
index 3880eaa1d..d5ca9433a 100644
--- a/myokit/_sim/fiber_tissue.py
+++ b/myokit/_sim/fiber_tissue.py
@@ -60,7 +60,7 @@ class FiberTissueSimulation(myokit.CModule):
     ``pace`` (per-cell)
         The pacing level, this is set if a protocol was passed in.
     ``diffusion_current`` (per-cell)
-        The current flowing from the cell to its neighbours. This will be
+        The current flowing from the cell to its neighbors. This will be
         positive when the cell is acting as a source, negative when it is
         acting as a sink.
 
diff --git a/myokit/_sim/mcl.h b/myokit/_sim/mcl.h
index d26ad503e..2be97189a 100644
--- a/myokit/_sim/mcl.h
+++ b/myokit/_sim/mcl.h
@@ -522,7 +522,7 @@ int mcl_platform_supports_extension(cl_platform_id platform_id, const char* exte
  *
  * Arguments:
  *  cl_platform_id platform_id  The id of the platform to query
- *  char* buffer                An initialised string buffer, that can be used
+ *  char* buffer                An initialized string buffer, that can be used
  *                              to read and write string information.
  *
  * Returns NULL and sets an error message if any exception occurs.
@@ -611,7 +611,7 @@ PyObject* mcl_info_platform_dict(cl_platform_id platform_id, size_t bufsize, cha
  * Arguments:
  *  cl_device_id device_id  The id of the device to query.
  *  size_t bufsize          Size of the string `buffer`.
- *  char* buffer            An initialised string buffer, that can be used to
+ *  char* buffer            An initialized string buffer, that can be used to
  *                          read and write string information.
  *
  * Returns NULL and sets an error message if any exception occurs.
diff --git a/myokit/_sim/openclsim.py b/myokit/_sim/openclsim.py
index 7d7eae670..299317179 100644
--- a/myokit/_sim/openclsim.py
+++ b/myokit/_sim/openclsim.py
@@ -58,7 +58,7 @@ class SimulationOpenCL(myokit.CModule):
     ``pace``
         The pacing level, this is set if a protocol was passed in.
     ``diffusion_current`` (if enabled)
-        The current flowing from the cell to its neighbours. This will be
+        The current flowing from the cell to its neighbors. This will be
         positive when the cell is acting as a source, negative when it is
         acting as a sink.
 
@@ -103,7 +103,7 @@ class SimulationOpenCL(myokit.CModule):
     cells ``i - 1`` and ``i + 1`` (except at the boundaries).
     Similarly, if ``ncells`` is a 2-dimensional tuple ``(nx, ny)`` a grid will
     be assumed so that each (non-boundary) cell is connected to four
-    neighbours.
+    neighbors.
     Finally, arbitrary geometries can be used by passing a scalar to ``ncells``
     and specifying the connections with :meth:`set_connections`.
 
@@ -765,9 +765,9 @@ def monodomain_conductance(self, chi, k, D, dx, A=1):
 
             I_diff[i] = sum[g[i,j] * (V[i] - V[j])]
 
-        in which the sum is over all neighbours ``j`` of cell ``i``.
+        in which the sum is over all neighbors ``j`` of cell ``i``.
 
-        Alternatively, with capacitance and currents normalised to membrane
+        Alternatively, with capacitance and currents normalized to membrane
         area, we can write::
 
             dV/dt = -1/cm (i_ion + i_stim + i_diff)
@@ -787,10 +787,10 @@ def monodomain_conductance(self, chi, k, D, dx, A=1):
 
             g_bar = (1 / chi) * (k / (k + 1)) * D * (1 / dx^2)
 
-        where ``g_bar`` is the cell-to-cell conductance, but normalised with
+        where ``g_bar`` is the cell-to-cell conductance, but normalized with
         respect to unit membrane area.
-        For models with currents normalised to area this is unproblematic, but
-        to convert to models with unnormalised currents this means we have
+        For models with currents normalized to area this is unproblematic, but
+        to convert to models with unnormalized currents this means we have
         added the further assumption that **each node contains some fixed
         amount of membrane**, determined by an area A::
 
@@ -825,9 +825,9 @@ def monodomain_conductance(self, chi, k, D, dx, A=1):
         """
         return D * A * k / ((k + 1) * chi * dx * dx)
 
-    def neighbours(self, x, y=None):
+    def neighbors(self, x, y=None):
         """
-        Returns a list of indices specifying the neighbours of the cell at
+        Returns a list of indices specifying the neighbors of the cell at
         index ``x`` (or index ``(x, y)`` for 2d simulations).
 
         Indices are given either as integers (1d or arbitrary geometry) or as
@@ -857,29 +857,38 @@ def neighbours(self, x, y=None):
 
         # User-specified connections (always 1d)
         if self._connections is not None:
-            neighbours = []
+            neighbors = []
             for i, j, c in self._connections:
                 if i == x:
-                    neighbours.append(j)
+                    neighbors.append(j)
                 elif j == x:
-                    neighbours.append(i)
-            return neighbours
+                    neighbors.append(i)
+            return neighbors
 
-        # Left and right neighbours
-        neighbours = []
+        # Left and right neighbors
+        neighbors = []
         if x > 0:
-            neighbours.append(x - 1)
+            neighbors.append(x - 1)
         if x + 1 < self._dims[0]:
-            neighbours.append(x + 1)
+            neighbors.append(x + 1)
 
-        # Top and bottom neighbours
+        # Top and bottom neighbors
         if len(self._dims) == 2:
-            neighbours = [(i, y) for i in neighbours]
+            neighbors = [(i, y) for i in neighbors]
             if y > 0:
-                neighbours.append((x, y - 1))
+                neighbors.append((x, y - 1))
             if y + 1 < self._dims[1]:
-                neighbours.append((x, y + 1))
-        return neighbours
+                neighbors.append((x, y + 1))
+        return neighbors
+
+    def neighbours(self, x, y=None):
+        """ Alias of :meth:`neighbors`. """
+        # Deprecated since 2023-06-07
+        import warnings
+        warnings.warn('The method SimulationOpenCL.neighbours() is deprecated.'
+                      ' Please use neighbors() instead.')
+
+        return self.neighbors(x, y)
 
     def pre(self, duration, report_nan=True, progress=None,
             msg='Pre-pacing SimulationOpenCL'):
@@ -1165,14 +1174,14 @@ def _run(self, duration, log, log_interval, report_nan, progress, msg):
                     vdiff = self._model.binding('diffusion_current')
                     vdiff = None if vdiff is None else vdiff.qname()
 
-                # List all neighbours for this cell
-                neighbours = self.neighbours(*icell)
+                # List all neighbors for this cell
+                neighbors = self.neighbors(*icell)
                 if len(self._dims) == 2:
-                    neighbours_str = ', '.join(
+                    neighbors_str = ', '.join(
                         ('(' + ','.join([str(i) for i in j]) + ')')
-                        for j in neighbours)
+                        for j in neighbors)
                 else:
-                    neighbours_str = ', '.join(str(j) for j in neighbours)
+                    neighbors_str = ', '.join(str(j) for j in neighbors)
 
                 # Show final state
                 txt.append('State during:')
@@ -1192,8 +1201,8 @@ def _run(self, duration, log, log_interval, report_nan, progress, msg):
                     txt.append(
                         '  Diffusion current: ' + myokit.float.str(
                             bounds[0][vdiff], precision=self._precision))
-                if neighbours:
-                    txt.append('  Connected cells: ' + neighbours_str)
+                if neighbors:
+                    txt.append('  Connected cells: ' + neighbors_str)
 
                 # Show previous state (and derivatives)
                 n_states = len(states)
@@ -1239,8 +1248,8 @@ def _run(self, duration, log, log_interval, report_nan, progress, msg):
                         txt.append(
                             '  Diffusion current: ' + myokit.float.str(
                                 bounds[1][vdiff], precision=self._precision))
-                    if neighbours:
-                        txt.append('  Connected cells: ' + neighbours_str)
+                    if neighbors:
+                        txt.append('  Connected cells: ' + neighbors_str)
 
                     # Show all variables with non-finite values
                     txt.append(
diff --git a/myokit/_sim/rhs.py b/myokit/_sim/rhs.py
index 6519c3d2d..e38f4b07e 100644
--- a/myokit/_sim/rhs.py
+++ b/myokit/_sim/rhs.py
@@ -33,7 +33,7 @@ class RhsBenchmarker(myokit.CModule):
     be selected.
 
     By default, the given list of variables are the only variables included in
-    a partial simulation. This behaviour can be inverted by setting
+    a partial simulation. This behavior can be inverted by setting
     ``exclude_selected=True``. With this setting, all variables except those in
     the given list will be tested.
 
diff --git a/myokit/_unit.py b/myokit/_unit.py
index 3852a357b..91638bcdf 100644
--- a/myokit/_unit.py
+++ b/myokit/_unit.py
@@ -516,7 +516,7 @@ def register(name, unit, quantifiable=False, output=False):
             ``True`` if this units name should be used to display this unit in.
             This should be set for all common units (m, kg, nm, Hz) but not for
             more obscure units (furlong, parsec). Having ``output`` set to
-            ``False`` will cause one-way behaviour: Myokit will recognise the
+            ``False`` will cause one-way behavior: Myokit will recognise the
             unit name but never use it in output.
             Setting this to ``True`` will also register the given name as a
             preferred representation format.
diff --git a/myokit/formats/ansic/_exporter.py b/myokit/formats/ansic/_exporter.py
index fb669d209..99d51e304 100644
--- a/myokit/formats/ansic/_exporter.py
+++ b/myokit/formats/ansic/_exporter.py
@@ -121,7 +121,7 @@ class AnsiCCableExporter(myokit.formats.TemplatedRunnableExporter):
     ``pace``
         The value of the pacing variable, implemented using the given protocol.
     ``diffusion_current``
-        The current flowing from each cell to its neighbours. This will be
+        The current flowing from each cell to its neighbors. This will be
         positive if the cell is acting as a source, negative when it's acting
         as a sink.
 
diff --git a/myokit/formats/channelml/_importer.py b/myokit/formats/channelml/_importer.py
index 032a255a4..a2b21b831 100644
--- a/myokit/formats/channelml/_importer.py
+++ b/myokit/formats/channelml/_importer.py
@@ -147,7 +147,7 @@ def _parse(self, path, model):
                 ' supported.')
 
         # Add channel component
-        name = self._sanitise_name(root.getAttribute('name'))
+        name = self._sanitize_name(root.getAttribute('name'))
         if name in model:
             name_root = name
             i = 2
@@ -200,7 +200,7 @@ def _parse(self, path, model):
         # Add gates
         gvars = []
         for gate in cvr.getElementsByTagName('gate'):
-            gname = self._sanitise_name(gate.getAttribute('name'))
+            gname = self._sanitize_name(gate.getAttribute('name'))
             gvar = component.add_variable(gname)
             gvar.promote(0)
             cstate = gate.getElementsByTagName('closed_state')
@@ -242,7 +242,7 @@ def _parse(self, path, model):
                         + gname + '>')
 
                 # Add closed-to-open transition
-                tname = self._sanitise_name(tco.getAttribute('name'))
+                tname = self._sanitize_name(tco.getAttribute('name'))
                 tcovar = gvar.add_variable(tname)
                 expr = str(tco.getAttribute('expr'))
                 try:
@@ -255,7 +255,7 @@ def _parse(self, path, model):
                     tcovar.meta['expression'] = str(expr)
 
                 # Add open-to-closed transition
-                tname = self._sanitise_name(toc.getAttribute('name'))
+                tname = self._sanitize_name(toc.getAttribute('name'))
                 tocvar = gvar.add_variable(tname)
                 expr = str(toc.getAttribute('expr'))
                 try:
@@ -284,7 +284,7 @@ def _parse(self, path, model):
                 tc = tc[0]
 
                 # Add steady-state variable
-                ssname = self._sanitise_name(ss.getAttribute('name'))
+                ssname = self._sanitize_name(ss.getAttribute('name'))
                 ssvar = gvar.add_variable(ssname)
                 expr = str(ss.getAttribute('expr'))
                 try:
@@ -296,7 +296,7 @@ def _parse(self, path, model):
                     ssvar.meta['expression'] = str(expr)
 
                 # Add time course variable
-                tcname = self._sanitise_name(tc.getAttribute('name'))
+                tcname = self._sanitize_name(tc.getAttribute('name'))
                 tcvar = gvar.add_variable(tcname)
                 expr = str(tc.getAttribute('expr'))
                 try:
@@ -412,7 +412,7 @@ def text(node, buff=None):
         return textwrap.fill(
             str('\n'.join(text(node))), 70, replace_whitespace=False)
 
-    def _sanitise_name(self, name):
+    def _sanitize_name(self, name):
         """
         Tests if a name is a valid myokit name. Adapts it if it isn't.
         """
diff --git a/myokit/formats/mathml/_parser.py b/myokit/formats/mathml/_parser.py
index 8128668ce..9d2728aae 100644
--- a/myokit/formats/mathml/_parser.py
+++ b/myokit/formats/mathml/_parser.py
@@ -84,7 +84,7 @@ class MathMLParser(object):
         will be added to this set.
 
     This is not a validating parser: if the MathML is invalid the method's
-    behaviour is undefined.
+    behavior is undefined.
 
     The following MathML elements are recognised:
 
diff --git a/myokit/gui/datablock_viewer.py b/myokit/gui/datablock_viewer.py
index 6bd46f963..d814967c9 100644
--- a/myokit/gui/datablock_viewer.py
+++ b/myokit/gui/datablock_viewer.py
@@ -1119,7 +1119,7 @@ def __init__(self):
         # Current position in time
         self._position = self._tmin
 
-        # Colours for drawing
+        # Colors for drawing
         self._color_temp = Qt.black
         self._color_cycle = [
             Qt.red,
@@ -1136,7 +1136,7 @@ def __init__(self):
             Qt.darkYellow,
         ]
 
-        # Scaling factors from pixels to normalised (0, 1) coordinates. Updated
+        # Scaling factors from pixels to normalized (0, 1) coordinates. Updated
         # after every resize.
         self._sw = 1.0
         self._sh = 1.0
@@ -1238,7 +1238,7 @@ def mouseMoveEvent(self, event):
         if self._last_variable is None:
             return
 
-        # Get normalised x, y coordinates ([0, 1])
+        # Get normalized x, y coordinates ([0, 1])
         p = event.pos()
         x = float(p.x()) * self._sw
         y = 1 - float(p.y()) * self._sh
diff --git a/myokit/gui/datalog_viewer.py b/myokit/gui/datalog_viewer.py
index c05e8ed56..78ffa27b3 100755
--- a/myokit/gui/datalog_viewer.py
+++ b/myokit/gui/datalog_viewer.py
@@ -757,7 +757,7 @@ def __init__(self, parent, log, filename):
                 self, TITLE, 'Unable to load file: no data found.')
             return
 
-        # Overlapping sweeps or neighbouring cells?
+        # Overlapping sweeps or neighboring cells?
         keys = []
         groups = {}
         for key in log.keys():
diff --git a/myokit/gui/source.py b/myokit/gui/source.py
index e30d0be03..16771cf52 100644
--- a/myokit/gui/source.py
+++ b/myokit/gui/source.py
@@ -54,7 +54,7 @@
 
 def _check_for_dark_mode(palette):
     """
-    Checks the default editor background color, and adjusts the colour scheme
+    Checks the default editor background color, and adjusts the color scheme
     if it looks like dark-mode is enabled.
     """
     c = palette.base().color()
diff --git a/myokit/lib/deps.py b/myokit/lib/deps.py
index 6d75f02af..3464f8645 100644
--- a/myokit/lib/deps.py
+++ b/myokit/lib/deps.py
@@ -455,7 +455,7 @@ def layout_layered(self):
         for n_runs in range(max_runs):
             change = False
             for i, layer in enumerate(layers):
-                # Set nodes to median of neighbours
+                # Set nodes to median of neighbors
                 for j, node in enumerate(layer):
                     n = len(node.edgi) + len(node.edgo)
                     if n > 0:
diff --git a/myokit/lib/guess.py b/myokit/lib/guess.py
index a91b0694b..5feef6b55 100644
--- a/myokit/lib/guess.py
+++ b/myokit/lib/guess.py
@@ -392,7 +392,7 @@ def membrane_potential(model):
     # Common units for the membrane potential
     common_units = [myokit.units.V]
 
-    # Non-dimensionalised (e.g. Mitchell-Schaeffer) use [1]
+    # Non-dimensionalized (e.g. Mitchell-Schaeffer) use [1]
     # But this causes too many false positives
     # common_units.append(myokit.units.dimensionless)
 
@@ -581,7 +581,7 @@ def stimulus_current(model):
         myokit.units.A / myokit.units.m**2,
     ]
 
-    # Non-dimensionalised (e.g. Mitchell-Schaeffer) use [mS/uF]
+    # Non-dimensionalized (e.g. Mitchell-Schaeffer) use [mS/uF]
     # But this causes too many false positives
     # common_units.append(myokit.units.S / myokit.units.F)
 
diff --git a/myokit/lib/markov.py b/myokit/lib/markov.py
index 90319878e..ccc9b648b 100644
--- a/myokit/lib/markov.py
+++ b/myokit/lib/markov.py
@@ -1704,7 +1704,7 @@ def _split_factor(term, variables):
                 'Non-linear function of ' + str(name) + ' found in '
                 + str(term) + '.')
 
-    # Finalise multiplier
+    # Finalize multiplier
     if m is None:
         m = myokit.Number(1)
     if not positive:
diff --git a/myokit/lib/plots.py b/myokit/lib/plots.py
index c0c01916f..f724ba54f 100644
--- a/myokit/lib/plots.py
+++ b/myokit/lib/plots.py
@@ -265,7 +265,8 @@ def current_arrows(log, voltage, currents, axes=None):
 
 def cumulative_current(
         log, currents, axes=None, labels=None, colors=None, integrate=False,
-        normalise=False, max_currents=None, line_args={}, fill_args={}):
+        normalize=False, max_currents=None, line_args={}, fill_args={},
+        normalise=None):
     """
     Plots a number of currents, one on top of the other, with the positive and
     negative parts of the current plotted separately.
@@ -291,8 +292,8 @@ def cumulative_current(
         current.
     ``integrate``
         Set this to ``True`` to plot total carried charge instead of currents.
-    ``normalise``
-        Set this to ``True`` to normalise the graph at every point, so that the
+    ``normalize``
+        Set this to ``True`` to normalize the graph at every point, so that the
         relative contribution of each current is shown.
     ``max_currents``
         Set this to any integer n to display only the first n currents, and
@@ -310,6 +311,15 @@ def cumulative_current(
     import matplotlib
     import matplotlib.pyplot as plt
 
+    # Deprecated on 2023-06-7
+    if normalize is not None:
+        import warnings
+        warnings.warn(
+            'The keyword argument `normalise` is deprecated. Please use'
+            ' `normalize` instead.')
+        normalize = normalise
+    del normalise
+
     # Get axes
     if axes is None:
         axes = plt.gca()
@@ -330,8 +340,8 @@ def cumulative_current(
     neg = np.minimum(pos, 0)
     pos = np.maximum(pos, 0)
 
-    # Normalise
-    if normalise:
+    # Normalize
+    if normalize:
         pos /= np.maximum(np.sum(pos, axis=0), 1e-99)
         neg /= -np.minimum(np.sum(neg, axis=0), -1e-99)
 


Test patch:
diff --git a/myokit/tests/test_lib_plots.py b/myokit/tests/test_lib_plots.py
index b7f554082..468a670e5 100755
--- a/myokit/tests/test_lib_plots.py
+++ b/myokit/tests/test_lib_plots.py
@@ -15,7 +15,7 @@
 import myokit
 import myokit.lib.plots as plots
 
-from myokit.tests import DIR_DATA
+from myokit.tests import DIR_DATA, WarningCollector
 
 
 class LibPlotTest(unittest.TestCase):
@@ -176,20 +176,28 @@ def test_cumulative_current(self):
         plt.close(fig)
         plt.show()
 
-        # Normalise currents
+        # Normalize currents
         fig = plt.figure()
-        plots.cumulative_current(d, currents, normalise=True)
+        plots.cumulative_current(d, currents, normalize=True)
         plt.legend()
         plt.close(fig)
         plt.show()
 
-        # Normalise currents and set maximum number of currents shown
+        # Normalize currents and set maximum number of currents shown
         fig = plt.figure()
-        plots.cumulative_current(d, currents, normalise=True, max_currents=3)
+        plots.cumulative_current(d, currents, normalize=True, max_currents=3)
         plt.legend()
         plt.close(fig)
         plt.show()
 
+        with WarningCollector() as w:
+            fig = plt.figure()
+            plots.cumulative_current(d, currents, normalise=True)
+            plt.legend()
+            plt.close(fig)
+            plt.show()
+        self.assertIn('deprecated', w.text())
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/myokit/tests/test_protocol_floating_point.py b/myokit/tests/test_protocol_floating_point.py
index bac1f10c7..9e79fdde7 100755
--- a/myokit/tests/test_protocol_floating_point.py
+++ b/myokit/tests/test_protocol_floating_point.py
@@ -125,7 +125,7 @@ def test_is_sequence_and_length_floats_3(self):
 
 class PacingSystemFloatingPointTest(unittest.TestCase):
     """
-    Test float behaviour in the Python PacingSystem implementation, using the
+    Test float behavior in the Python PacingSystem implementation, using the
     log_for_interval method.
     """
 
diff --git a/myokit/tests/test_simulation_opencl.py b/myokit/tests/test_simulation_opencl.py
index 75708c849..a4cdc34fe 100755
--- a/myokit/tests/test_simulation_opencl.py
+++ b/myokit/tests/test_simulation_opencl.py
@@ -621,7 +621,7 @@ def test_diffusion_free(self):
         self.assertRaisesRegex(
             RuntimeError, 'method is unavailable', s.is_paced, 0)
         self.assertRaisesRegex(
-            RuntimeError, 'method is unavailable', s.neighbours, 0)
+            RuntimeError, 'method is unavailable', s.neighbors, 0)
         self.assertRaisesRegex(
             RuntimeError, 'method is unavailable', s.set_conductance)
         self.assertRaisesRegex(
@@ -691,105 +691,110 @@ def test_initial_value_expressions(self):
         self.assertEqual(x, m.initial_values(True) * 2)
         self.assertEqual(x, s.default_state())
 
-    def test_neighbours_0d(self):
-        # Test listing neighbours in a 0d simulation
+    def test_neighbors_0d(self):
+        # Test listing neighbors in a 0d simulation
 
-        x = self.s0.neighbours(0)
+        x = self.s0.neighbors(0)
         self.assertEqual(len(x), 0)
         self.assertRaisesRegex(
-            IndexError, 'out of range', self.s0.neighbours, -1)
+            IndexError, 'out of range', self.s0.neighbors, -1)
         self.assertRaisesRegex(
-            IndexError, 'out of range', self.s0.neighbours, 1)
+            IndexError, 'out of range', self.s0.neighbors, 1)
         self.assertRaisesRegex(
-            ValueError, '1-dimensional', self.s0.neighbours, 0, 1)
+            ValueError, '1-dimensional', self.s0.neighbors, 0, 1)
 
-    def test_neighbours_1d(self):
-        # Test listing neighbours in a 1d simulation
+        # Test alias
+        with WarningCollector() as w:
+            self.assertEqual(self.s0.neighbours(0), self.s0.neighbors(0))
+        self.assertIn('deprecated', w.text())
+
+    def test_neighbors_1d(self):
+        # Test listing neighbors in a 1d simulation
 
         # Left edge
-        x = self.s1.neighbours(0)
+        x = self.s1.neighbors(0)
         self.assertEqual(len(x), 1)
         self.assertIn(1, x)
         # Middle
-        x = self.s1.neighbours(1)
+        x = self.s1.neighbors(1)
         self.assertEqual(len(x), 2)
         self.assertIn(0, x)
         self.assertIn(2, x)
         # Right edge
-        x = self.s1.neighbours(9)
+        x = self.s1.neighbors(9)
         self.assertEqual(len(x), 1)
         self.assertIn(8, x)
 
         # Out of range
         self.assertRaisesRegex(
-            IndexError, 'out of range', self.s1.neighbours, -1)
+            IndexError, 'out of range', self.s1.neighbors, -1)
         self.assertRaisesRegex(
-            IndexError, 'out of range', self.s1.neighbours, 10)
+            IndexError, 'out of range', self.s1.neighbors, 10)
         self.assertRaisesRegex(
-            ValueError, '1-dimensional', self.s1.neighbours, 0, 1)
+            ValueError, '1-dimensional', self.s1.neighbors, 0, 1)
 
-    def test_neighbours_1d_connections(self):
-        # Test listing neighbours in a 1d simulation with arbitrary geometry
+    def test_neighbors_1d_connections(self):
+        # Test listing neighbors in a 1d simulation with arbitrary geometry
 
         try:
             g = 1
             self.s1.set_connections(
                 [(0, 1, g), (0, 2, g), (3, 0, g), (3, 2, g)])
-            x = self.s1.neighbours(0)
+            x = self.s1.neighbors(0)
             self.assertEqual(len(x), 3)
             self.assertIn(1, x)
             self.assertIn(2, x)
             self.assertIn(3, x)
-            x = self.s1.neighbours(1)
+            x = self.s1.neighbors(1)
             self.assertEqual(len(x), 1)
             self.assertIn(0, x)
-            x = self.s1.neighbours(2)
+            x = self.s1.neighbors(2)
             self.assertEqual(len(x), 2)
             self.assertIn(0, x)
             self.assertIn(3, x)
-            x = self.s1.neighbours(3)
+            x = self.s1.neighbors(3)
             self.assertEqual(len(x), 2)
             self.assertIn(0, x)
             self.assertIn(2, x)
-            x = self.s1.neighbours(4)
+            x = self.s1.neighbors(4)
             self.assertEqual(len(x), 0)
         finally:
             # Restore defaults
             self.s1.set_conductance()
 
-    def test_neighbours_2d(self):
-        # Test listing neighbours in a 2d simulation
+    def test_neighbors_2d(self):
+        # Test listing neighbors in a 2d simulation
 
         # Corners
-        x = self.s2.neighbours(0, 0)
+        x = self.s2.neighbors(0, 0)
         self.assertEqual(len(x), 2)
         self.assertIn((1, 0), x)
         self.assertIn((0, 1), x)
-        x = self.s2.neighbours(3, 2)
+        x = self.s2.neighbors(3, 2)
         self.assertEqual(len(x), 2)
         self.assertIn((3, 1), x)
         self.assertIn((2, 2), x)
 
         # Edges
-        x = self.s2.neighbours(1, 0)
+        x = self.s2.neighbors(1, 0)
         self.assertEqual(len(x), 3)
         self.assertIn((0, 0), x)
         self.assertIn((2, 0), x)
         self.assertIn((1, 1), x)
-        x = self.s2.neighbours(3, 1)
+        x = self.s2.neighbors(3, 1)
         self.assertEqual(len(x), 3)
         self.assertIn((2, 1), x)
         self.assertIn((3, 0), x)
         self.assertIn((3, 2), x)
 
         # Middle
-        x = self.s2.neighbours(1, 1)
+        x = self.s2.neighbors(1, 1)
         self.assertEqual(len(x), 4)
         self.assertIn((0, 1), x)
         self.assertIn((2, 1), x)
         self.assertIn((1, 0), x)
         self.assertIn((1, 2), x)
-        x = self.s2.neighbours(2, 1)
+        x = self.s2.neighbors(2, 1)
         self.assertEqual(len(x), 4)
         self.assertIn((1, 1), x)
         self.assertIn((3, 1), x)
@@ -798,15 +803,15 @@ def test_neighbours_2d(self):
 
         # Out of range
         self.assertRaisesRegex(
-            IndexError, 'out of range', self.s2.neighbours, -1, 0)
+            IndexError, 'out of range', self.s2.neighbors, -1, 0)
         self.assertRaisesRegex(
-            IndexError, 'out of range', self.s2.neighbours, 0, -1)
+            IndexError, 'out of range', self.s2.neighbors, 0, -1)
         self.assertRaisesRegex(
-            IndexError, 'out of range', self.s2.neighbours, 4, 0)
+            IndexError, 'out of range', self.s2.neighbors, 4, 0)
         self.assertRaisesRegex(
-            IndexError, 'out of range', self.s2.neighbours, 0, 3)
+            IndexError, 'out of range', self.s2.neighbors, 0, 3)
         self.assertRaisesRegex(
-            ValueError, '2-dimensional', self.s2.neighbours, 0)
+            ValueError, '2-dimensional', self.s2.neighbors, 0)
 
     def test_protocol(self):
         # Tests changing the protocol
diff --git a/myokit/tests/test_unit.py b/myokit/tests/test_unit.py
index 999a3000a..4af40e96f 100755
--- a/myokit/tests/test_unit.py
+++ b/myokit/tests/test_unit.py
@@ -79,7 +79,7 @@ def test_close(self):
         self.assertFalse(myokit.Unit.close(not_pF2, pF2))
         self.assertFalse(myokit.Unit.close(pF2, not_pF2))
 
-        # The next test is not a requirement, but tests the current behaviour:
+        # The next test is not a requirement, but tests the current behavior:
         u = myokit.units.m * 1.000000001
         self.assertTrue(myokit.Unit.close(u, myokit.units.m))