This work introduces JuPyLive, a migration mechanism that enables seamless transition of Jupyter notebooks between local resources of user's workstation and remote resources of high-performance computing~(HPC) environments, while preserving the user experience. JuPyLive eliminates the underlying complexities of migration process, enabling users to freely choose among available local and remote res
JuPyLive is a migration mechanism that enables the seamless, bidirectional transition of Jupyter notebooks between local workstations and High-Performance Computing (HPC) environments while preserving the user experience. Developed by Sima Attar-Khorasani, Matthias Lieber, and Siavash Ghiasvand, it allows users to switch computational resources on demand via a single click within the familiar Jupyter interface, eliminating the need for code changes or manual configuration.
The system operates by leveraging the ElasticNotebook framework to manage in-memory state migration and automating resource allocation on HPC clusters via Slurm. Key features include:
Currently, JuPyLive natively supports Slurm schedulers and is designed to democratize HPC access for interdisciplinary researchers by bridging the gap between interactive local development and powerful remote batch processing.
JuPyLive addresses a practical discontinuity in interactive scientific computing: Jupyter notebooks are easy to run on a workstation, but moving the same notebook onto a high-performance computing (HPC) cluster often breaks the user’s workflow. Users may have to reconfigure environments, transfer files, resubmit jobs, and lose kernel state or session context. The system presents a migration mechanism that lets notebook resources move between local laptop resources and remote HPC resources while preserving the user experience, effectively making the notebook appear to continue running across different compute backends.
Its key contribution is the abstraction of notebook execution as a migratable resource rather than a fixed local process. By hiding the underlying mechanics of resource selection, session continuity, and state transfer, JuPyLive allows users to choose among local and remote resources without manually managing the migration process. The central insight is that the friction in HPC use is not only about raw compute access, but also about maintaining an interactive, stateful workflow; if notebook resources can be moved transparently, users can exploit HPC-scale hardware without abandoning the convenience of local development.
This matters because it lowers the barrier to using HPC systems for data science, simulation, and machine-learning workflows that may outgrow laptop resources. By enabling a smoother path from exploratory local analysis to larger-scale remote execution—and potentially back again—JuPyLive can make HPC more accessible to researchers who rely on Jupyter-centric workflows. More broadly, it points toward hybrid compute environments where interactive notebooks can elastically span personal workstations, clusters, and cloud or HPC resources.
JuPyLive is a migration mechanism for Jupyter notebooks that allows an interactive notebook session to move between a user’s local workstation and remote high-performance computing (HPC) resources while maintaining a coherent user experience. The work addresses a practical but important gap in modern data-science and HPC workflows: notebooks are often developed locally for convenience, yet many workloads eventually require the storage, compute, or software environment available only on a cluster. Rather than forcing users to manually copy files, restart kernels, reconfigure environments, or re-authenticate to remote systems, JuPyLive aims to make the transition transparent enough that the notebook remains usable across execution backends.
The key contribution is the abstraction of notebook execution away from a fixed local environment. By treating the notebook as a portable interactive workload, JuPyLive can expose local and remote resources as selectable execution targets and handle the underlying migration concerns—such as preserving session context, aligning environments, and managing the shift from workstation-class resources to cluster-scale resources. This is conceptually similar to live migration in systems work, but specialized to the stateful, interactive, and environment-sensitive nature of Jupyter workflows. The result is a system-level answer to a common usability problem: users can begin work on a laptop and continue it on HPC without breaking the notebook-based development loop.
The work matters because it lowers the barrier between exploratory notebook development and production-scale HPC execution. For technically literate users—researchers, engineers, data scientists, and students—this can reduce setup friction, improve resource utilization, and make large-scale data or compute tasks more accessible. More broadly, JuPyLive supports a workflow model in which the notebook is not merely a local artifact but a portable unit of interactive computation, which is increasingly relevant for reproducible research, remote laboratory work, and hybrid local/cloud/HPC environments.