# ReservoirPy's quick example ends at `predictions = e`, and three files declare its dependencies

> An Inria library for reservoir computing and echo state networks, with hyperparameter search, a scikit-learn bridge and a JAX backend. The mechanics are documented carefully. The first thing a reader copies is cut off mid-assignment.

**reservoirpy/reservoirpy** — A simple and flexible code for Reservoir Computing architectures like Echo State Networks

- Repository: https://github.com/reservoirpy/reservoirpy
- Website: https://reservoirpy.readthedocs.io/
- Stars: 658 · Forks: 155
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/reservoirpy-reservoirpy

## The quick example stops at predictions = e

The Mackey-Glass example is the first code on the page, and it is three commented steps. It loads a 2000-step series, shifts it into a forecasting pair with a 0.2 test share, builds an echo state network with 100 units, spectral radius 1.25, leak rate 0.3 and ridge 1e-5, then fits with a warmup of 100. The block ends here:

```python
esn.fit(x_train, y_train, warmup=100)
predictions = e
```

The third step is titled fit, run and evaluate, so the missing text is the run and the evaluation. The imports at the top of the same block name two observables, `rmse` and `rsquare`, which nothing in the visible code uses, which confirms that the cut fell between the prediction and the scores. A reader copying the block gets a syntax error on the last line and has to look elsewhere for how to turn a fitted network into a prediction.

## Three files declare the dependencies and only one holds the metadata

The repository carries a pyproject.toml, a setup.py and a requirements.txt, and they do different jobs. pyproject.toml contains a build system section requiring setuptools and wheel, plus a formatter configuration, and nothing else. All of the package metadata is in setup.py: the name, the description, author and maintainer contact addresses at Inria, the long description read from the readme at build time, project URLs, classifiers, and the dependency lists. requirements.txt then repeats the runtime dependencies and appends every extra in the same flat file. So there are three places where a version floor lives and one place where the package declares itself, and nothing in the build configuration enforces that they agree. The root also carries a coverage configuration, a pre-commit configuration, a ReadTheDocs configuration, a setup.cfg, a Pipfile and a contributing guide, so the toolchain around the package is broader than the packaging itself.

## The version number is produced by executing a module

The version is not a literal in the packaging file. setup.py opens a version file inside the package directory and executes whatever it contains:

```python
__version__ = ""
version_file = os.path.join("reservoirpy", "_version.py")
with open(version_file) as f:
    exec(f.read())
```

The download URL is then built from that value as a source tarball named after the tag. This is a common pattern for keeping the installed version and the tag in step without a build step, and it has the obvious consequence that building the package requires the source tree rather than a wheel alone, since the file has to be present and has to be valid Python. The formatter configuration in pyproject targets Python 3.8, which is the oldest interpreter the project advertises anywhere on this page.

## The documented install and the requirements file install different stacks

One command is documented:

```bash
pip install reservoirpy
```

That gives you the three runtime dependencies and nothing else: joblib at 1.3.0 or newer, numpy at 1.21.1 or newer, and scipy at 1.4.1 or newer, none of them capped above. The extras are declared separately, a hyper group with hyperopt, matplotlib and tqdm for the graphical hyperparameter search, a sklearn group for the scikit-learn nodes, and a jax group for the JAX backend, where scikit-learn is the only dependency with an upper bound, held below 1.7.0. Installing from requirements.txt instead pulls all of that at once, so the two documented routes give you different machines, and the page only documents the smaller one, deferring the rest to a guide on the documentation site.

## A patch release and a minor release three days apart

Three recent tags tell the release story. v0.3.15 was published on 24 September 2025, v0.3.16 on 5 June 2026, and v0.4.2 on 8 June 2026, so a patch release and a minor release landed three days apart after a nine-month gap, which reads like a coordinated re-tag rather than a steady cadence. The default branch has been pushed to as late as 2 October 2026, four months past the newest tag, so the source you read on the default branch is ahead of what pip installs. The project page for the changelog and the user guide are both present in the file as commented-out markup, so the header links you would use to check either one are inert.

## The paper reproductions are partial, and one filename misspells plasticity

The examples folder is described as partial reproductions of published work, and the wording is doing real work there. Four notebooks are listed, each in its own directory whose name contains spaces and is percent-encoded in the link: intrinsic plasticity after Schrauwen and colleagues from 2008, interactive reservoir computing for chunking information streams after Asabuki and colleagues from 2018, next-generation reservoir computing after Gauthier and colleagues from 2021, and an edge of stability echo state network after Ceni and colleagues from 2023. The first notebook's filename spells plasticity as `Intrinsic_Plasiticity_Schrauwen_et_al_2008.ipynb`, and the fourth carries two surnames in its filename while the citation names one. Useful starting points, with the caveats the page states.

## Seven tutorials, and the library names itself after the field, not the paper

The tutorial list is the most complete part of the documentation surface, and it is numbered one to seven: getting started, advanced features, a general introduction to reservoir computing, understanding and optimising hyperparameters, classification, interfacing with scikit-learn, and an introduction to the JAX backend. Each is offered as both a repository notebook and a Colab link. The feature list above them advertises multiple reservoirs including deep ones and multiple readouts, feedback loops, offline and online training, parallelisation across sequences, sparse matrix support, and three named learning rules: intrinsic plasticity, local plasticity, and NVAR. The papers section lists four publications using the library with HAL, arXiv and code links, ending with an invitation to contact the maintainers to be added, and its last entry stops partway through a URL.

## Conclusion

This is a mature research library where the numbers are specific and the API surface is small: four constructor arguments for an echo state network, an explicit warmup length, a train and test split ratio, and observables imported by name. Two things get in the way of running it from this page alone. The quick example stops at the line that would have produced the predictions and scores, so the last step of the advertised workflow is missing rather than merely undocumented. And the dependency story is spread over three files that have to agree, with the packaging metadata in one, a build configuration in another and a flat requirements list in the third, while the documented install command gives you only the core three packages and not the extras the feature list advertises. Before starting, read the version of the API you have installed against the tutorial that matches it, because the release history shows a minor version and a patch version landing three days apart. It suits someone already working in reservoir computing. It does not suit someone copying the front page and expecting a result.

## FAQ

### What is ReservoirPy?

An MIT licensed Python library for reservoir computing architectures such as echo state networks, from Inria, with Xavier Hinaut as author and Xavier Hinaut and Paul Bernard as maintainers. It supports multiple and deep reservoirs, feedback loops, online and offline training, parallelisation across sequences, sparse weight matrices, intrinsic and local plasticity rules, NVAR, and scikit-learn interop.

### How do I install ReservoirPy?

With `pip install reservoirpy`, which brings joblib, numpy and scipy. Three extras are defined for hyperparameter search with hyperopt and matplotlib, scikit-learn nodes, and the JAX backend, held below scikit-learn 1.7.0 for that group. The page sends you to the documentation site for the more complete installation rather than showing the commands.

### Does ReservoirPy have a JAX backend?

There is a jax extra requiring jax 0.4 or newer, and the seventh tutorial is an introduction to the JAX backend. The page does not describe GPU support or any performance difference, only that the backend exists as a separate optional dependency group.

### Which papers does ReservoirPy reproduce in its examples?

Four, and the page calls them partial reproductions: intrinsic plasticity after Schrauwen and colleagues 2008, interactive reservoir computing for chunking information streams after Asabuki and colleagues 2018, next-generation reservoir computing after Gauthier and colleagues 2021, and an edge of stability echo state network after Ceni and colleagues 2023.

## Sources

- [License: MIT](https://github.com/reservoirpy/reservoirpy/blob/master/LICENSE)
- [Project website](https://reservoirpy.readthedocs.io/)
- [README](https://github.com/reservoirpy/reservoirpy/blob/master/README.md)
- [Releases](https://github.com/reservoirpy/reservoirpy/releases)
- [reservoirpy/reservoirpy on GitHub](https://github.com/reservoirpy/reservoirpy)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/reservoirpy-reservoirpy