Self-Hosted EEG & MEG Neuroimaging Processing: MNE-Python vs FieldTrip vs EEGLAB Guide

Introduction

Electroencephalography (EEG) and magnetoencephalography (MEG) are the workhorses of non-invasive brain research, capturing neural activity with millisecond temporal resolution. From clinical epilepsy monitoring to brain-computer interfaces, these modalities generate rich time-series data that require sophisticated processing pipelines. While commercial packages like Curry and BrainVision Analyzer offer polished interfaces, the open-source neuroimaging ecosystem provides tools with greater flexibility, reproducibility, and no licensing costs.

This guide compares three leading self-hosted EEG/MEG processing frameworks: MNE-Python (the Python powerhouse for neuroimaging data), FieldTrip (the MATLAB toolbox with unparalleled breadth), and EEGLAB (the veteran GUI-driven EEG analysis environment). Each serves distinct user communities and analysis workflows, and understanding their complementary strengths is essential for building an effective neuroimaging processing pipeline.

Feature Comparison

MNE-Python has become the de facto standard for MEG analysis and is increasingly dominant in EEG research. Developed by the MNE community with core contributions from Martinos Center (MGH/Harvard), it provides a unified Python API for the entire neuroimaging pipeline: raw data loading and visualization, preprocessing (filtering, artifact rejection, ICA), epoching, evoked responses, time-frequency analysis, source localization, connectivity, and statistical testing. The mne.Report class generates shareable HTML reports with interactive figures, making it ideal for collaborative or clinical workflows.

FieldTrip, from the Donders Institute in the Netherlands, offers the most comprehensive set of analysis methods — it has been the reference implementation for many algorithms later ported to other packages. Its real-time processing buffer enables closed-loop neurofeedback and brain-computer interface experiments. FieldTrip’s data structures are the basis for the Brain Imaging Data Structure (BIDS) specification for MEG/EEG. For researchers who need cutting-edge methods before they appear elsewhere (e.g., novel connectivity metrics or source reconstruction algorithms), FieldTrip is often the first implementation available.

EEGLAB, from the Swartz Center for Computational Neuroscience at UCSD, pioneered GUI-driven EEG analysis. Its visual interface makes it accessible to researchers without programming backgrounds, while its plugin architecture (50+ community plugins) dramatically extends functionality. EEGLAB’s STUDY module enables group-level analysis across dozens of subjects, and plugins like LIMO provide hierarchical linear modeling for single-trial statistics. For clinical EEG research and teaching environments, EEGLAB’s interactive workflow remains unmatched.

Deploying MNE-Python as a Self-Hosted Processing Server

MNE-Python integrates naturally with JupyterHub for multi-user neuroimaging servers:

1
2
3
4
5

# Install MNE-Python with full dependencies
pip install mne[full] mne-bids jupyterhub

# Install JupyterHub for multi-user access
pip install jupyterhub jupyterlab

Docker Compose for a complete neuroimaging server:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

version: "3.8"
services:
  neuro-server:
    image: jupyter/scipy-notebook:latest
    command: start.sh jupyter lab --LabApp.token=''
    ports:
      - "8888:8888"
    volumes:
      - ./data:/home/jovyan/data
      - ./notebooks:/home/jovyan/work
    environment:
      - JUPYTER_ENABLE_LAB=yes
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

Example preprocessing pipeline in MNE-Python:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

import mne

# Load raw EEG/MEG data
raw = mne.io.read_raw_fif("subject01_raw.fif", preload=True)

# Apply bandpass filter and notch filter
raw.filter(l_freq=0.5, h_freq=40.0)
raw.notch_filter(freqs=[50, 100])  # Line noise

# Run ICA for artifact removal
ica = mne.preprocessing.ICA(n_components=20, random_state=97)
ica.fit(raw)
ica.plot_components()

# Remove EOG artifacts
eog_indices, eog_scores = ica.find_bads_eog(raw)
ica.exclude = eog_indices
raw_clean = ica.apply(raw.copy())

# Epoch data around events
events = mne.find_events(raw_clean)
epochs = mne.Epochs(raw_clean, events, tmin=-0.2, tmax=0.8,
                    baseline=(None, 0), preload=True)

# Compute and plot evoked response
evoked = epochs.average()
evoked.plot(joint=True)

# Generate report
report = mne.Report(title="Subject 01 Preprocessing")
report.add_raw(raw_clean, title="Cleaned Raw")
report.add_evokeds(evoked, titles="Auditory Evoked")
report.save("report.html")

Setting Up FieldTrip on a Shared Server

FieldTrip runs in MATLAB and can be served through MATLAB Web App Server or headless batch processing:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

% Add FieldTrip to MATLAB path
addpath('/opt/fieldtrip');
ft_defaults;

% Load MEG data and preprocess
cfg = [];
cfg.dataset = 'subject01.ds';
cfg.channel = 'MEG';
cfg.demean = 'yes';
cfg.bpfilter = 'yes';
cfg.bpfreq = [1 40];
data = ft_preprocessing(cfg);

% Frequency analysis
cfg = [];
cfg.method = 'mtmconvol';
cfg.taper = 'hanning';
cfg.foi = 1:1:40;
cfg.t_ftimwin = 0.5 * ones(size(cfg.foi));
freq = ft_freqanalysis(cfg, data);

% Source localization with LCMV beamformer
cfg = [];
cfg.method = 'lcmv';
cfg.grid = load('sourcemodel.mat');
cfg.headmodel = load('headmodel.mat');
source = ft_sourceanalysis(cfg, freq);

For headless batch processing, containerize MATLAB Runtime with compiled FieldTrip:

1
2
3
4
5

FROM ubuntu:22.04
RUN apt-get update && apt-get install -y matlab-runtime-r2024a
COPY compiled_analysis /app/
WORKDIR /app
CMD ["./run_analysis.sh", "/opt/MATLAB/R2024a"]

Running EEGLAB in Clinical and Research Environments

EEGLAB’s plugin ecosystem makes it uniquely extensible. A typical clinical deployment uses EEGLAB with the ICLabel plugin for automated artifact classification:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

% Start EEGLAB
eeglab;

% Load data
EEG = pop_loadset('filename', 'subject01.set', 'filepath', '/data/subject01/');

% High-pass filter
EEG = pop_eegfiltnew(EEG, 'locutoff', 1.0);

% Run ICA with ICLabel classification
EEG = pop_runica(EEG, 'icatype', 'runica', 'extended', 1);
EEG = pop_iclabel(EEG, 'default');

% Automatically classify and remove components
EEG = pop_icflag(EEG, [NaN NaN; 0.9 1; 0.9 1; 0.9 1; 0.9 1; 0.9 1; NaN NaN]);
EEG = pop_subcomp(EEG, find(EEG.reject.gcompreject), 0);

% Save cleaned data
pop_saveset(EEG, 'filename', 'subject01_clean.set', 'filepath', '/data/output/');

Building a Multi-Modal Neuroimaging Pipeline

For research groups processing both EEG and MEG data, a hybrid pipeline combining multiple tools is common. Use MNE-Python for core preprocessing (it handles MEG data best), export to FieldTrip for specialized analyses (e.g., specific connectivity metrics), and use EEGLAB for visual inspection and ICA artifact rejection in clinical workflows. Our RF signal analysis guide demonstrates complementary signal processing patterns, and our software-defined radio guide covers spectral analysis techniques that apply to EEG frequency-domain work.

For high-throughput processing, use GNU Parallel or workflow managers to process subjects independently:

1
2

# Process 100 subjects in parallel with MNE-Python
ls data/sub-*/ | parallel -j 16 'python process_subject.py {}'

FAQ

Which tool should I choose for my first EEG analysis project?

If you’re comfortable with Python, start with MNE-Python — its documentation, tutorials, and community are excellent. If you prefer a graphical interface and have access to MATLAB, EEGLAB provides the gentlest learning curve with its visual pipeline. If you need cutting-edge analysis methods not available elsewhere, FieldTrip is the most comprehensive (but has a steeper learning curve due to its MATLAB heritage and extensive options).

Can I run these tools without a MATLAB license?

MNE-Python is fully open-source with zero licensing costs — it’s Python-based and free. FieldTrip and EEGLAB require MATLAB (commercial license), but both work with GNU Octave (free) for basic functionality. For full FieldTrip or EEGLAB functionality, MATLAB is recommended. For Octave-based EEGLAB, expect longer processing times and some plugin incompatibilities. Budget approximately $2,150 for a perpetual MATLAB license or $860/year for academic pricing.

How do these tools handle large datasets (100+ subjects)?

MNE-Python excels with large datasets through memory mapping (.fif files are read on-demand) and integration with job schedulers (SLURM, PBS). FieldTrip’s ft_freqanalysis and ft_sourceanalysis support distributed computing via the cfg.parallel option, distributing jobs across MATLAB workers. EEGLAB’s STUDY module handles group-level analysis across hundreds of subjects through efficient data structures but may require 32+ GB RAM for very large studies. All three tools can process data on HPC clusters.

What file formats are supported for importing data?

MNE-Python reads 30+ formats natively: FIF (Elekta/MEGIN), FIF (CTF), 4D/BTI, KIT, EDF, BDF, BrainVision, EEGLAB .set, FieldTrip .mat, EGI, Nicolet, Biosemi, and more. FieldTrip supports all major MEG formats plus EEG via its ft_read_header/ft_read_data functions. EEGLAB reads EDF, BDF, BrainVision, Neuroscan, Biosemi, and many more through its FileIO plugin. All three support BIDS-format datasets, which is increasingly the standard for shared neuroimaging data.

What compute resources do I need for source localization?

Source localization is the most computationally intensive step. A beamformer (LCMV/DICS) on a single subject with 15,000 source points and 1-minute of MEG data (306 channels) takes approximately 30 seconds on a modern 16-core CPU with MNE-Python. Minimum norm estimates (MNE/dSPM/sLORETA) are faster (2-5 seconds per subject). For group studies with 50+ subjects, 32-64 cores and 64-128 GB RAM are recommended. GPU acceleration is available through CUDA for specific operations in MNE-Python (ICA, filtering) but is not yet mainstream for source imaging.

💰 想测试你的市场判断力？我用 Polymarket 做预测市场交易——这是全球最大的预测市场平台，从大选结果到技术监管时间线，什么都可以押注。和赌博不同，这是真正的信息市场：你懂的信息越多，胜率越高。我靠预测技术相关事件的走向已经赚了不少。用我的邀请链接注册：Polymarket.com