Build EEG pipelines like a studio session.

Overview

Signal Studio turns an EEG analysis pipeline into something you can see. Instead of a 400-line Python script, you place cards on a canvas, wire them together into a workflow, and let the engine execute the graph. Models — from a simple SVM to an EEG-Conformer — drop in as specialised cards.

The whole system is built on three primitives. Everything else is a combination of them:

Core concepts

Install & first run

Signal Studio is a native desktop app (macOS / Windows) with a Python engine running underneath. After install, the node palette is populated from Resources/cards/index.json.

Cards — what is a card

A card is the atomic unit of work. It declares what it consumes, what it produces, and renders a faceplate so you can tune it. The engine loads any folder containing a card.json — builtin cards from Resources/cards/, and user cards when third-party loading is on.

Signal Studio ships 93 builtin cards plus 2 user examples (user.hjorth_extractor, user.example.echo). They span the entire pipeline, from temporal filtering to deep-learning architectures and live monitors.

Card anatomy

Every card is two files in a folder: a declarative manifest and an implementation.

{
  "id": "signalstudio.band_pass",
  "name": "Band Pass",
  "category": "preprocessing.temporal",
  "inputs":  [{ "id": "in",  "type": "Raw|Epochs" }],
  "outputs": [{ "id": "out", "type": "Raw|Epochs" }],
  "params": {
    "l_freq": { "type": "float", "default": 1.0 },
    "h_freq": { "type": "float", "default": 40.0 }
  },
  "run": { "phase": "preprocessing.temporal", "entry": "run.py" }
}

# Receives typed inputs + params, returns typed outputs.
def run(ctx):
    raw = ctx.inputs["in"]
    out = raw.copy().filter(
        l_freq=ctx.params["l_freq"],
        h_freq=ctx.params["h_freq"],
    )
    return { "out": out }

Card catalog

The 93 builtin cards are grouped by pipeline role. A condensed map:

Temporal preprocessing · preprocessing.temporal

Spatial preprocessing · preprocessing.spatial

Artifacts & cleaning

Events & data

Epoching & rejection

Analysis

Machine learning

Deep learning

Visualisation & monitors

Live monitors render results as the graph runs — 22 of them, plus visualisation cards.

Authoring a card

If you can write a Python function, you can write a card. Create a folder with a card.json describing the I/O and params, and a run.py exposing a run(ctx) function. Drop it in the user cards folder, enable third-party cards, restart — it appears in the palette with full typed wiring.

Skinning cards

Skins are pure visual faceplates — they change how a card looks, never what it does. A skin is a .sscard file with role skin, targeting a specific card id (e.g. signalstudio.notch_premium_skin → signalstudio.notch). Browse and publish them on the Instruments page; install via Install skin… or drag-and-drop.

Workflows — the canvas

A workflow is what you get when cards are wired together. The canvas is an infinite 2D space; connections carry typed data from one card's output port to the next card's input. The engine resolves the graph into an execution order based on each card's run.phase.

Pipeline model

Data flows left-to-right through phases. A typical EEG pipeline:

The Workflow Library (rail → Workflows) ships 5 one-click pipelines that drop a full chain onto the canvas. Each requires an EEG or Dataset source already present (except Motor Imagery, which lays down a complete FBCSP workflow).

Execution & caching

When you run a workflow, the engine topologically sorts the graph and executes each card once its inputs are ready. Outputs are cached per card, so re-running after tweaking a downstream parameter only recomputes what changed — not the whole pipeline.

Saving & sharing

Workflows save as .sbuilder files — a serialisation of the canvas graph, card params, and layout. Share them with collaborators, or publish recipes the community can open and run on their own data via the Workflows library.

Models — the model layer

Models are estimators you train and run inside a workflow. In the Builder's Models tab, each library tile places a ready-made ML or DL pipeline on the canvas — the architecture card plus its fit/predict plumbing. Under the hood they're regular cards, so they wire into the same graph.

Model catalog

Classic ML — geometry- and feature-based estimators:

Deep learning — convolutional, sequence/transformer, and specialised architectures:

Inputs & outputs

Models don't stand alone — they sit between feature-producing cards and evaluation monitors. A canonical ML chain:

Epochs
  → Epochs Vectorizer      # flatten to feature matrix
  → Standard Scaler
  → Train / Test Split     # before any fit — avoid leakage
  → Model Fit (svm)
  → Model Predict
  → Confusion Matrix + ROC / AUC

Placeable ML building blocks (beyond the library tiles): epochs_vectorizer, label_extractor, standard_scaler, bandpower_extractor, train_test_split, leakage_auditor, model_fit, model_predict.

Bring your own

Because architectures are declared as cards (*_architecture) feeding Neural Net Fit / Neural Net Predict, you can author a new architecture card the same way you author any card — expose a builder function returning your model, and it slots into the existing training/inference plumbing.

Data formats

Glossary

Counts reflect the current repo: 93 builtin cards + 2 user examples · 5 Builder workflows · 16 model tiles. Something missing or unclear? Ask on the community forum.