Add a why integrate your software with spikeinterface section (#4393)

Author: chrishalcrow

README.md

@@ -46,11 +46,17 @@
 
 [![Twitter](https://img.shields.io/badge/@spikeinterface-%231DA1F2.svg?style=for-the-badge&logo=Twitter&logoColor=white)](https://twitter.com/spikeinterface) [![Mastodon](https://img.shields.io/badge/-@spikeinterface-%232B90D9?style=for-the-badge&logo=mastodon&logoColor=white)](https://fosstodon.org/@spikeinterface)
 
+Please [Star](https://github.com/SpikeInterface/spikeinterface/stargazers) the project to support us and [Watch](https://github.com/SpikeInterface/spikeinterface/subscription) to always stay up-to-date!
 
-SpikeInterface is a Python framework designed to unify preexisting spike sorting technologies into a single code base.
+SpikeInterface is a Python package designed to unify preexisting spike sorting technologies into a single code base. If you use SpikeInterface, you are also using code and ideas from many other projects. Our codebase would be tiny without the amazing algorithms and formats that we interface with. See them all, and how to cite them, on our [references page](https://spikeinterface.readthedocs.io/en/latest/references.html). In the past year, we have added support for the following tools:
 
-Please [Star](https://github.com/SpikeInterface/spikeinterface/stargazers) the project to support us and [Watch](https://github.com/SpikeInterface/spikeinterface/subscription) to always stay up-to-date!
+- SLAy. [SLAy-ing oversplitting errors in high-density electrophysiology spike sorting](https://www.biorxiv.org/content/10.1101/2025.06.20.660590v2) ([docs](https://spikeinterface.readthedocs.io/en/latest/modules/curation.html#auto-merging-units))
+- Lupin, Spykingcicus2 and Tridesclous2. [Opening the black box: a modular approach to spike sorting](https://www.biorxiv.org/content/10.64898/2026.01.23.701239v1) ([docs](https://spikeinterface.readthedocs.io/en/stable/modules/sorters.html#supported-spike-sorters))
+- rtsort. [RT-Sort: An action potential propagation-based algorithm for real time spike detection and sorting with millisecond latencies](https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0312438) ([docs](https://spikeinterface.readthedocs.io/en/stable/modules/sorters.html#supported-spike-sorters))
+- MEDiCINe. [MEDiCINe: Motion Correction for Neural Electrophysiology Recordings](https://www.eneuro.org/content/12/3/ENEURO.0529-24.2025) ([docs](https://spikeinterface.readthedocs.io/en/latest/how_to/handle_drift.html))
+- UnitRefine. [UnitRefine: A Community Toolbox for Automated Spike Sorting Curation](https://www.biorxiv.org/content/10.1101/2025.03.30.645770v2) ([docs](https://spikeinterface.readthedocs.io/en/latest/tutorials_custom_index.html#automated-curation-tutorials))
 
+If you would like us to add another tool, or you would like to integrate your project with our package, please [open an issue](https://github.com/SpikeInterface/spikeinterface/issues).
 
 With SpikeInterface, users can:
 

doc/development/development.rst

@@ -248,6 +248,74 @@ Note, however, that the running time of the command above will be quite long. If
 
     pytest src/spikeinterface/core/ --cov=spikeinterface/core --cov-report html
 
+
+Integrate your software with SpikeInterface
+-------------------------------------------
+
+You've made a great analysis tool for ephys data - congrats! It's popular and people are using it.
+Why would you integrate it into SpikeInterface? And how can do you do that?
+
+Why integrate it
+^^^^^^^^^^^^^^^^
+
+SpikeInterface is designed to allow users to 1) read in any recording format 2) apply a wide variety
+of preprocessing steps to the recording 3) run any sorter on the data 4) compute standard
+postprocessing data about the sorting (and more!!). We work hard to be general and allow users to do
+anything they'd like with their data. Hence if your tool works with SpikeInterface, it works with an
+enormous array of possible analysis pipelines.
+
+When they're first written, analysis tools are usually designed in a specific lab and are tested
+with a small number of collaborators and datasets. It's technically difficult to design a tool
+which can be applied to data from a wide variety of devices, set-ups and sorters. There are many
+edge cases and "gotcha"s to consider. But the SpikeInterface team have extensive experience with
+exactly this problem. We know how to write code so that it doesn't depend on data-specific or
+sorter-specific quirks. Hence we can help generalize the tool and widen its potential userbase.
+
+Often, the first step when using an analysis tool is to wrangle the data into a specific format:
+"please save your recording to a binary file which is preprocessed in a certain way" or "ensure your
+sorting output is in this format". SpikeInterface deals with this painful data wrangling for you: we
+load many formats and internally represent them in a consistent way. We also apply all preprocessing
+steps lazily, meaning that users never need to save a copy of a preprocessed recording: they can work
+directly from the raw recording. We believe this reduces the barrier to entry for the end user, which
+makes your tool more likely to be used by many researchers.
+
+How to integrate it
+^^^^^^^^^^^^^^^^^^^
+
+If you'd like to integrate your tool into SpikeInterface: amazing! Just
+`raise an issue <https://github.com/SpikeInterface/spikeinterface/issues>`_. There are two main ways
+to integrate your software into SpikeInterface.
+
+1) Wrapping
+
+You keep your code in your own codebase, and write a thin wrapper in SpikeInterface which interacts
+with your library. Most external sorters that SpikeInterface can call are organized in this way. To
+use the tool, the user will have to install your package and the maintenance of the software is primarily
+on your shoulders.
+
+2) Integration
+
+You re-implement your code and add it to the SpikeInterface package. Many preprocessing steps, motion
+correction algorithms and postprocessing steps are implemented like this. Your method and code become
+part of the SpikeInterface package and we take on the maintenance burden (with your help, we hope!).
+
+In this case, we don't expect the re-implementation to be a perfect copy of the code, since we may need
+to change the code to work for a more general set of data.
+
+
+Credit and Citation
+^^^^^^^^^^^^^^^^^^^
+
+We want to ensure the tools that SpikeInterface wrap and integrate are properly cited. We'll ensure that
+credit is given when the tool is mentioned in the docs, in the docstring of the function, and we will
+add it to the :doc:`../references` page. When added, we will include your software on the front-page of
+the SpikeInterface GitHub for at least 1 year. If we fail to cite you properly, this is certainly a mistake.
+Please `raise an issue <https://github.com/SpikeInterface/spikeinterface/issues>`_.
+
+See all the packages and projects which have been wrapped or integrated into SpikeInterface in our
+:doc:`../references` page.
+
+
 Implement a new extractor
 -------------------------
 

doc/index.rst

@@ -7,6 +7,19 @@ SpikeInterface is a Python module to analyze extracellular electrophysiology dat
 With a few lines of code, SpikeInterface enables you to load and pre-process the recording, run several
 state-of-the-art spike sorters, post-process and curate the output, compute quality metrics, and visualize the results.
 
+If you use SpikeInterface, you are also using code and ideas from many other projects. Our codebase would be tiny without the
+amazing algorithms and formats that we interface with. See them all, and how to cite them, on our
+`references page <https://spikeinterface.readthedocs.io/en/latest/references.html>`_. In the past year, we have added support
+for the following tools:
+
+- SLAy. `SLAy-ing oversplitting errors in high-density electrophysiology spike sorting <https://www.biorxiv.org/content/10.1101/2025.06.20.660590v2>`_ (`docs <https://spikeinterface.readthedocs.io/en/latest/modules/curation.html#auto-merging-units>`_)
+- Lupin, Spykingcicus2 and Tridesclous2. `Opening the black box: a modular approach to spike sorting <https://www.biorxiv.org/content/10.64898/2026.01.23.701239v1>`_ (`docs <https://spikeinterface.readthedocs.io/en/stable/modules/sorters.html#supported-spike-sorters>`_)
+- RT-Sort. `RT-Sort: An action potential propagation-based algorithm for real time spike detection and sorting with millisecond latencies <https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0312438>`_ (`docs <https://spikeinterface.readthedocs.io/en/stable/modules/sorters.html#supported-spike-sorters>`_)
+- MEDiCINe. `MEDiCINe: Motion Correction for Neural Electrophysiology Recordings <https://www.eneuro.org/content/12/3/ENEURO.0529-24.2025>`_ (`docs <https://spikeinterface.readthedocs.io/en/latest/how_to/handle_drift.html>`_)
+- UnitRefine. `UnitRefine: A Community Toolbox for Automated Spike Sorting Curation <https://www.biorxiv.org/content/10.1101/2025.03.30.645770v2>`_ (`docs <https://spikeinterface.readthedocs.io/en/latest/tutorials_custom_index.html#automated-curation-tutorials>`_)
+
+If you would like us to add another tool, or you would like to integrate your project with our package, please
+`open an issue <https://github.com/SpikeInterface/spikeinterface/issues>`_.
 
 Overview of SpikeInterface modules
 ----------------------------------
@@ -21,7 +34,7 @@ SpikeInterface is made of several modules to deal with different aspects of the
 - pre-process extracellular recordings.
 - run many popular, semi-automatic spike sorters (kilosort1-4, mountainsort4-5, spykingcircus,
   tridesclous, ironclust, herdingspikes, yass, waveclus)
-- run sorters developed in house (lupin, spkykingcicus2, tridesclous2, simple) that compete with
+- run sorters developed in house (lupin, spykingcicus2, tridesclous2, simple) that compete with
   kilosort4
 - run theses polar sorters without installation using containers (Docker/Singularity).
 - post-process sorted datasets using th SortingAnalyzer

doc/modules/curation.rst

@@ -154,6 +154,9 @@ merges. It offers multiple "presets" and the flexibility to apply individual ste
     # here we apply the merges
     analyzer_merged = analyzer.merge_units(merge_unit_groups=merge_unit_groups)
 
+Currently, we support the following presets: 'similarity_correlograms', 'temporal_splits', 'x_contaminations',
+'feature_neighbors' and 'slay'. Find out more about SLAy in their preprint: [Koukuntla]_.
+
 There is also the convenient :py:func:`~spikeinterface.curation.auto_merge_units` function that combines the
 :py:func:`~spikeinterface.curation.compute_merge_unit_groups` and :py:func:`~spikeinterface.core.SortingAnalyzer.merge_units` functions.
 This is a high level function that allows you to apply either one or several presets/lists of steps in one go. For example, let's