MINDFUL is an open-source analytical framework for evaluating the system-level feasibility of implantable Brain–Computer Interface (BCI) systems-on-chip (SoCs) under realistic biological, thermal, and architectural constraints.
This repository contains the Python implementation of the MINDFUL framework, released as the official artifact accompanying:
MINDFUL: Safe, Implantable, Large-Scale Brain-Computer Interfaces from a System-Level Design Perspective
Guy Eichler et al., MICRO 2025
MINDFUL provides a first-principles, system-level model that captures how implantable BCI systems scale as the number of neural interface channels increases. It analytically models the interaction between neural data acquisition, on-implant computation, and wireless communication, while enforcing power-density–based thermal safety, area constraints, and real-time throughput requirements.
The framework abstracts implanted BCI SoCs as a streaming, real-time data pipeline, enabling parameterized comparison of architectural choices, identification of dominant bottlenecks, and projection of long-term scaling limits.
MINDFUL is intended for:
- computer architects and hardware designers exploring application-specific SoC architectures for BCIs,
- BCI application and AI researchers assessing whether computational models are compatible with implantable constraints, and
- interdisciplinary researchers seeking a consistent system-level perspective across architecture, circuits, neuroscience, and AI.
The repository separates core analytical models, system definitions, and experiment drivers, closely reflecting the structure of the MINDFUL framework and the analyses presented in the paper.
MINDFUL_MICRO25/
│
├── framework/
│ ├── QAM.py
│ ├── helper.py
│ ├── networks.py
│ └── optimization.py
│
├── settings/
│ ├── soc_struct.py
│ ├── socs_to_test.py
│ └── structs.py
│
├── scaling/
│ ├── scaling_ook_comm.py
│ ├── scaling_qam_comm.py
│ ├── scaling_dnn_comp.py
│ ├── scaling_layers_comp.py
│ └── scaling_all_opt_comp.py
│
├── comm_centric_ook.py
├── comm_centric_ook_show.py
├── comm_centric_qam.py
├── comm_centric_qam_show.py
│
├── comp_centric_dnn.py
├── comp_centric_dnn_show.py
├── comp_centric_dnn_layers.py
├── comp_centric_dnn_layers_compare.py
├── comp_centric_optimization.py
├── comp_centric_optimization_show.py
│
├── create_dirs.py
├── LICENSE
├── .gitignore
└── README.md
QAM.py– analytical models for QAM-based wireless communication.helper.py– shared helper functions used across analyses.networks.py– analytical cost models translating AI/DNN architectures into MAC counts and real-time constraints.optimization.py– analytical models for computation-centric optimization strategies.
soc_struct.py– data structures describing implanted SoC components.structs.py– shared data structures for SoCs, communication IPs, and AI/DNN architectures.socs_to_test.py– concrete SoC design points evaluated in the paper.
scaling_ook_comm.py– OOK communication-centric scaling equations.scaling_qam_comm.py– QAM communication-centric scaling equations.scaling_dnn_comp.py– scaling equations for fully on-implant DNN execution.scaling_layers_comp.py– scaling equations for DNN partitioning between implant and wearable.scaling_all_opt_comp.py– scaling equations for computation-centric optimizations.
The framework requires the following Python packages (as listed in the artifact appendix):
pip install numpy matplotlib scipy sympy shapelyThe following modules are part of the Python standard library and require no installation:
math, sys, os.
The artifact was tested using Python 3.9.
Before running any experiments, create the required output directories used to store generated data, figures, and logs:
python create_dirs.pyThis repository contains all scripts required to reproduce the analytical results and scaling trends presented in the MICRO’25 MINDFUL paper.
Each experiment evaluates feasibility limits as neural interface scale increases, subject to:
- implantable power-density (thermal) constraints,
- SoC area constraints, and
- real-time throughput requirements.
All numerical results are written to data/, and figures are generated in figures/.
These experiments study designs where wireless communication dominates system feasibility, corresponding to the communication-centric analyses in the paper.
OOK-based communication (Figures 5 and 6)
python comm_centric_ook.py
python comm_centric_ook_show.py- Evaluates feasibility limits when neural data is transmitted using OOK modulation.
- Produces scaling trends showing how communication bandwidth and power dominate as channel count increases.
QAM-based communication (Figure 7)
python comm_centric_qam.py
python comm_centric_qam_show.py- Evaluates whether higher spectral efficiency via QAM improves scalability.
- Quantifies trade-offs between communication efficiency and additional circuit complexity.
These experiments evaluate designs where computation is pushed onto the implant to reduce communication bandwidth, corresponding to the computation-centric analyses in the paper.
Fully on-implant DNN execution (Figure 10)
python comp_centric_dnn.py
python comp_centric_dnn_show.py- Evaluates feasibility limits of executing a full DNN-based decoder on the implant.
- Demonstrates when computation becomes the dominant bottleneck under implantable constraints.
DNN partitioning between implant and wearable (Figure 11)
python comp_centric_dnn_layers.py
python comp_centric_dnn_layers_compare.py- Implements the DNN splitting optimization introduced in the paper.
- Evaluates how partitioning DNN layers between the implant and the wearable affects system feasibility.
- Shows how partial on-implant computation extends scalable operating regimes.
Computation-centric optimization (Figure 12)
python comp_centric_optimization.py
python comp_centric_optimization_show.py- Evaluates additional optimization strategies discussed in the paper.
- Quantifies how architectural specialization and design choices shift feasibility boundaries.
MINDFUL is designed to support systematic extension and community-driven exploration of future implantable BCI systems. The framework separates structural definitions from analytical cost models, allowing new designs to be evaluated without rewriting experiments.
Extensions typically fall into two categories: SoC and communication design and AI/DNN computation.
System- and communication-level structures are defined in:
settings/
├── soc_struct.py
└── structs.py
Concrete design points are instantiated in:
settings/socs_to_test.py
To add a new design:
- define or reuse the appropriate structural descriptions, and
- add a new design instance in
socs_to_test.py.
All scaling analyses automatically include the new design.
AI/DNN architecture parameters are defined in:
settings/structs.py
Analytical cost models that map these architectures to system-level requirements are implemented in:
framework/networks.py
Each analytical function corresponds to a specific class of network architecture and computes:
- total MAC operations,
- throughput requirements, and
- real-time execution constraints.
To add a new AI or DNN architecture:
- define its structural parameters in
settings/structs.py, and - implement a matching analytical cost model in
framework/networks.py.
Existing analytical models can be reused only when their assumptions match the new architecture.
- Numerical results:
data/ - Figures:
figures/ - Logs:
logs/
If you use this framework or build upon it in academic work, please cite:
@inproceedings{EichlerMICRO25MINDFUL,
title = {MINDFUL: Safe, Implantable, Large-Scale Brain-Computer Interfaces from a System-Level Design Perspective},
author = {Eichler, Guy and Gilhotra, Yatin and Zeng, Nanyu and Kim, Martha and Shepard, Kenneth L. and Carloni, Luca P.},
booktitle = {Proceedings of the 58th IEEE/ACM International Symposium on Microarchitecture (MICRO)},
year = {2025}
}This project is released under the Apache License, Version 2.0 (Apache-2.0).
See the LICENSE file for details.
Contributions that extend the analytical models or improve clarity and documentation are welcome.