---
id: simdkalman
version: "1.0.4"
license: MIT
license_treatment: permissive
maintenance: dormant
---

# simdkalman — Kalman filters vectorized as Single Instruction, Multiple Data

License: permissive · Maintenance: dormant · Downloads: 89.4K/mo

## What it is and what it does

simdkalman provides a vectorized implementation of Kalman filtering designed to run many independent filters simultaneously over batches of time series. Instead of looping over individual series, it uses NumPy's array operations to process all series at once, trading a single loop for parallel computation. The package exposes a KalmanFilter class that accepts standard Kalman parameters (state transition, process noise, observation model, observation noise) and provides smooth() and predict() methods to filter and forecast data.

The main use case is when you have many independent time series that need the same Kalman filter applied—for example, smoothing sensor readings from 1000 independent devices, or filtering multiple stock prices with the same model. In such cases, vectorization can yield substantial speedups. The package depends only on NumPy and installs as a pure Python wheel, making it lightweight. Maintenance is dormant (last release 972 days ago), but the code is marked Production/Stable and carries no known vulnerabilities.

Use it for:

- Smooth and denoise batches of independent time series (e.g., sensor data from multiple devices) with a single Kalman filter applied to all.
- Forecast multiple independent sequences forward in time using the same learned or fixed Kalman model.
- Accelerate Kalman filtering workloads where the bottleneck is running the same filter many times over different data.
- Estimate hidden state trajectories for multiple parallel processes (e.g., tracking multiple objects with the same motion model).
- Implement expectation-maximization (EM) for Kalman filter parameter learning when you have many independent observation sequences.

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

Implements vectorized Kalman filters that run many independent filters in parallel over multiple time series using NumPy's array operations, enabling fast filtering and smoothing of batched observations.

Yes, if you need to apply Kalman filters to many independent time series in parallel. The vectorized design and low install friction make it a good fit for batch filtering tasks. However, maintenance is dormant—no updates in 972 days—so evaluate whether you need ongoing support or can work with a stable but no-longer-maintained codebase. No known vulnerabilities and MIT licensing present no barriers.

## Install

pip install simdkalman
uv add simdkalman
poetry add simdkalman

## Installing simdkalman

Before you install: Low friction: pure Python wheel with only NumPy as a runtime dependency. Maintenance is dormant—last release was 972 days ago—but the repository remains active and the package is marked Production/Stable.

License in practice: MIT license is permissive; you can use, modify, and distribute this package with minimal restrictions, provided you include the license notice.

Quickstart:

pip install simdkalman

import simdkalman
import numpy as np

kf = simdkalman.KalmanFilter(
    state_transition=np.array([[1,1],[0,1]]),
    process_noise=np.diag([0.1, 0.01]),
    observation_model=np.array([[1,0]]),
    observation_noise=1.0)

data = np.random.normal(size=(200, 1000))
smoothed = kf.smooth(data)
pred = kf.predict(data, 15)

Verify before relying:

- Whether the package works reliably with modern Python versions (3.9+) despite dormant maintenance status.
- Performance claims of 100x speedup over pykalman and 70x over filterpy are from examples/benchmark.py; real-world gains depend on problem structure.

## Package facts

- License: MIT (permissive)
- Python support: unspecified
- Install friction: low
- Maintenance: dormant
- Downloads: 89.4K/month (top 15,000 on PyPI)
- Known vulnerabilities: none known

## Tags

kalman filter vectorized, batch kalman filtering, simd kalman python, time series smoothing, kalman filter multiple series, fast kalman implementation, vectorized state estimation, time-series-analysis, state-estimation, vectorized-computation

[View on SkillFed](https://skillfed.io/packages/simdkalman) · [View on PyPI](https://pypi.org/project/simdkalman/)