Jupyter Core
raw JSON → 5.9.1 verified Tue May 12 auth: no python install: verified quickstart: stale
Jupyter-core is the foundational package that provides core common functionality for Jupyter projects. It includes base application classes, configuration management, and path utilities upon which other Jupyter components (like Jupyter Notebook, JupyterLab, and Jupyter Server) rely. Currently at version 5.9.1, it frequently receives patch releases for bug fixes and security updates, with minor and major versions introducing significant changes like Python version requirements and directory structure adjustments.
pip install jupyter-core Common errors
error ModuleNotFoundError: No module named 'jupyter_core' ↓
cause The `jupyter_core` package is not installed in the active Python environment or is not accessible to the Jupyter installation.
fix
Ensure
jupyter-core is installed in your environment. If using pip, run pip install jupyter-core. If using conda, run conda install jupyter-core. If it's already installed, try upgrading it: pip install --upgrade jupyter-core or conda update jupyter-core. error Error executing Jupyter command 'notebook': [Errno 2] No such file or directory ↓
cause The `jupyter` command or the `jupyter-notebook` executable is not found in the system's PATH, or the Jupyter installation itself is corrupted or incomplete.
fix
Ensure Jupyter is correctly installed and its executables are in your system's PATH. Try reinstalling Jupyter:
pip uninstall jupyter jupyter_core notebook then pip install jupyter notebook, or conda uninstall jupyter_core notebook then conda install jupyter_core notebook. You might also try running python -m notebook directly. error PermissionError: [Errno 13] Permission denied: '/usr/local/share/jupyter' (or similar path) ↓
cause The Jupyter application, often when attempting to create or write configuration or runtime files, lacks the necessary file system permissions for the specified directory.
fix
Adjust file permissions for the affected directory (e.g.,
~/.jupyter, /usr/local/share/jupyter, or ~/.local/share/jupyter). On Linux/macOS, you might use sudo chmod -R 775 /usr/local/share/jupyter or sudo chown -R $(whoami) ~/.jupyter as appropriate for your setup, though care should be taken with sudo and broad permissions. Running jupyter notebook --generate-config might also create necessary directories with correct permissions. error ImportError: DLL load failed: The specified module could not be found. (related to jupyter_core.paths and pywin32 on Windows) ↓
cause On Windows, this error typically occurs when the `pywin32` package, which `jupyter_core` uses for secure file operations, is either not installed correctly or is incompatible with the Python environment.
fix
Reinstall or upgrade the
pywin32 package: pip uninstall pywin32 then pip install pywin32. Ensure your Python environment and pywin32 installation match your system's architecture (32-bit or 64-bit). Sometimes, reinstalling Jupyter entirely can also resolve underlying dependency issues. error ERROR: jupyter-server X.X.X has requirement jupyter-core>=Y.Y.Y, but you'll have jupyter-core Z.Z.Z which is incompatible. ↓
cause There is a version incompatibility between `jupyter-core` and another core Jupyter package (like `jupyter-server` or `jupyter-client`) in your environment.
fix
Upgrade all related Jupyter packages to compatible versions. The safest way is often to perform a full upgrade:
pip install --upgrade jupyter jupyterlab jupyter_core jupyter_client jupyter_server traitlets nbformat. If using conda, use conda update --all in the relevant environment or conda install jupyter jupyterlab jupyter_core jupyter_client jupyter_server traitlets nbformat to explicitly set up compatible versions. Warnings
breaking Jupyter-core 5.9.0 and later require Python 3.10 or newer. Support for Python 3.7 was dropped in version 5.0. ↓
fix Ensure your Python environment is 3.10 or higher before upgrading to jupyter-core 5.9.x. For older versions, ensure Python 3.8+.
deprecated The JUPYTER_PLATFORM_DIRS environment variable was introduced in v5.0 to opt-in to using more appropriate platform-specific directories. It raises a deprecation warning if not set. In future versions (v6 and v7), this behavior will become opt-out, then the environment variable checks and old directory logic will be entirely removed. ↓
fix Set JUPYTER_PLATFORM_DIRS in your environment to explicitly opt-in to the new behavior to suppress warnings and prepare for future versions.
gotcha Version 5.9.0 introduced a regression affecting Windows users (specifically a TypeError in filterwarnings()), which was fixed in 5.9.1. Similarly, 5.8.0 had a regression related to SYSTEM_CONFIG_PATH assumptions that was fixed in 5.8.1. ↓
fix Always upgrade to the latest patch release (e.g., 5.9.1 or higher for 5.9.x stream, 5.8.1 or higher for 5.8.x stream) to avoid known regressions.
breaking In version 5.9.0, the dependency on `pywin32` for Windows was removed to unblock installation on free-threaded Python. While generally a positive change, existing setups that might have implicitly relied on `pywin32` being present through `jupyter-core` might need adjustments if other components still require it. ↓
fix Verify `pywin32` is explicitly installed if other components in your Jupyter ecosystem still have a direct requirement for it on Windows.
gotcha Starting with version 5.0, Jupyter-core prioritizes environment-level configuration paths over user-level paths when running in a virtual environment. The `JUPYTER_PREFER_ENV_PATH` environment variable can be set to opt-out of this behavior if user-level paths should take precedence. ↓
fix If your environment relies on a specific path priority, explicitly set `JUPYTER_PREFER_ENV_PATH` to '0' to prefer user directories or remove it to prefer environment directories.
breaking Version 5.8.0 included a security fix for CVE-2025-30167 / GHSA-33p9-3p43-82vq on Windows. This is a critical update for all Windows users. ↓
fix Upgrade to jupyter-core 5.8.0 or a later version immediately, especially if deploying on Windows.
breaking The `jupyter_core.paths.jupyter_path()` function returns a list of directory paths, not a dictionary. Attempting to call the `.items()` method on its return value will result in an `AttributeError`. ↓
fix To iterate over the paths, iterate directly over the list returned by `jupyter_core.paths.jupyter_path()`. If the intention is to retrieve different types of Jupyter paths categorized by type, separate functions like `jupyter_core.paths.jupyter_config_path()` and `jupyter_core.paths.jupyter_data_dir()` should be used and their outputs processed accordingly.
Install compatibility verified last tested: 2026-05-12
python os / libc status wheel install import disk
3.10 alpine (musl) - - 0.04s 19.0M
3.10 slim (glibc) - - 0.04s 19M
3.11 alpine (musl) - - 0.10s 21.0M
3.11 slim (glibc) - - 0.08s 21M
3.12 alpine (musl) - - 0.07s 12.8M
3.12 slim (glibc) - - 0.07s 13M
3.13 alpine (musl) - - 0.04s 12.5M
3.13 slim (glibc) - - 0.06s 13M
3.9 alpine (musl) - - 0.17s 18.4M
3.9 slim (glibc) - - 0.10s 19M
Imports
- jupyter_data_dir
from jupyter_core.paths import jupyter_data_dir - jupyter_config_dir
from jupyter_core.paths import jupyter_config_dir - jupyter_path wrong
import jupyter_core.paths as jp; jp.paths()correctfrom jupyter_core.paths import jupyter_path - JupyterApp
from jupyter_core.application import JupyterApp - run_sync
from jupyter_core.utils import run_sync
Quickstart stale last tested: 2026-04-23
import os
from jupyter_core.paths import jupyter_data_dir, jupyter_config_dir, jupyter_runtime_dir, jupyter_path
from jupyter_core.application import JupyterApp
print(f"Jupyter Data Directory: {jupyter_data_dir()}")
print(f"Jupyter Config Directory: {jupyter_config_dir()}")
print(f"Jupyter Runtime Directory: {jupyter_runtime_dir()}")
print("\nJupyter Search Paths (example of core configuration paths):")
# jupyter_path() returns a dictionary, typically with keys like 'data_path', 'config_path', 'runtime_path'
for path_type, paths in jupyter_path().items():
if paths:
print(f" {path_type.replace('_path', ' Path').replace('_', ' ').title()}:")
for path in paths:
print(f" - {path}")
# JupyterApp is a base class, usually subclassed for actual applications.
# This demonstrates its availability for inheritance.
class MyJupyterCoreApp(JupyterApp):
name = "my-core-app"
description = "A simple example of subclassing JupyterApp"
def initialize(self, argv=None):
super().initialize(argv)
self.log.info(f"MyJupyterCoreApp initialized. Config file: {self.config_file}")
def start(self):
self.log.info("MyJupyterCoreApp started.")
if __name__ == '__main__':
# Instantiate a dummy app to show it loads, but won't run a full loop without more setup
try:
app = MyJupyterCoreApp(argv=[]).initialize()
print("\nSuccessfully initialized a basic JupyterApp instance.")
except Exception as e:
print(f"\nCould not initialize MyJupyterCoreApp (expected for this minimal example): {e}")