comm

Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc.

comm Permissive license BSD 3-Clause License Copyright (c) 2022, Jupyter All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following… (full text in the JSON record) AGING ★ 12 v0.2.3 released 2025-07-25

Install

comm on PyPI

pip

pip install comm

uv

uv add comm

poetry

poetry add comm

Package facts

License	BSD 3-Clause License Copyright (c) 2022, Jupyter All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following… (full text in the JSON record) (permissive)
Python support	supports the current Python release (>=3.8)
Install friction	low — pure-Python wheel
Runtime dependencies	none
Maintenance	aging — 384 days since the last release
Last repo commit	2025-11-24
First released	2020-11-02
Popularity	one of the top 1,000 most-downloaded packages on PyPI (30-day window, as of 2026-08-13)
Known vulnerabilities	none known (OSV.dev, checked 2026-08-13)

Evidence: comm-0.2.3-py3-none-any.whl

Keywords: ipykernel, jupyter, xeus-python

Framework :: JupyterLicense :: OSI Approved :: BSD LicenseProgramming Language :: PythonProgramming Language :: Python :: 3

About comm

from the package's own PyPI description — quoted content, verbatim

Comm

It provides a way to register a Kernel Comm implementation, as per the Jupyter kernel protocol. It also provides a base Comm implementation and a default CommManager that can be used.

Register a comm implementation in the kernel:

Case 1: Using the default CommManager and the BaseComm implementations

We provide default implementations for usage in IPython:

import comm


class MyCustomComm(comm.base_comm.BaseComm):
    def publish_msg(self, msg_type, data=None, metadata=None, buffers=None, **keys):
        # TODO implement the logic for sending comm messages through the iopub channel
        pass


comm.create_comm = MyCustomComm

This is typically what ipykernel and JupyterLite's pyolite kernel will do.

Case 2: Providing your own comm manager creation implementation

import comm

comm.create_comm = custom_create_comm
comm.get_comm_manager = custom_comm_manager_getter

This is typically what xeus-python does (it has its own manager implementation using xeus's C++ messaging logic).

Comm users

Libraries like ipywidgets can then use the comms implementation that has been registered by the kernel:

```python from comm import...

Read as markdown · JSON record · Source repository · Homepage

AI interpretation — verify before relying

AI-generated interpretation of the package facts above; every digit, version, license, or vulnerability id it cites is grounded in the facts already shown on this page

Comm provides a Jupyter kernel protocol implementation for registering and managing inter-process communication (comms) between kernels and frontends, enabling libraries like ipywidgets to send messages through a standardized interface.

Installation is straightforward with no runtime dependencies and a pure-Python wheel distribution. The package shows aging maintenance (384 days since last release) but remains actively used in the Jupyter ecosystem; the last commit is recent (2025-11-24), suggesting ongoing stewardship despite infrequent releases.

Distributed under the permissive BSD 3-Clause License, which allows commercial and private use with minimal restrictions—only requiring preservation of copyright and license notices in redistributions.

Usage

pip install comm

import comm

comm_manager = comm.get_comm_manager()
my_comm = comm.create_comm()
comm_manager.register_comm(my_comm)

Requires Python 3.8 or later; kernel implementations must provide a concrete comm creation function via comm.create_comm before comm.get_comm_manager() can be used.

Verdict: Comm is a lightweight, well-maintained foundational library for Jupyter kernel communication with permissive licensing and no external dependencies. Its aging release cadence is typical for stable infrastructure; it remains actively supported and is essential for Jupyter-based interactive computing stacks. Suitable for production use in Jupyter environments.

Needs verification

Whether the 384-day gap since last release reflects planned maintenance cycles or reduced active development
Compatibility guarantees across different Jupyter kernel implementations (ipykernel, xeus-python, JupyterLite)
Performance characteristics under high-frequency message loads

jupyter kernel comm protocolipykernel communication interfacejupyter widget messagingkernel comm manageripywidgets backend communicationjupyter comm implementationkernel frontend messaging