---
id: posix-ipc
version: "1.3.2"
license: BSD-3-Clause
license_treatment: permissive
maintenance: active
---

# posix-ipc — POSIX IPC primitives (semaphores, shared memory and message queues) for Python

License: permissive · Maintenance: active · Downloads: 448.3K/mo

## What it is and what it does

posix_ipc is a C-based Python module that wraps POSIX Realtime Extensions (POSIX 1003.1b-1993) inter-process communication primitives. It lets you create and manage semaphores, shared memory segments, and message queues for coordinating work across multiple processes on Unix-like systems. The module has no runtime dependencies and exposes these low-level IPC mechanisms directly to Python, making it suitable for applications that need efficient, kernel-level process synchronization without higher-level abstractions.

The package is production-stable (Development Status 5), actively maintained, and has been in use since its first release with no reported bugs in the core code for seven years. Pre-built wheels are available for common platforms, though building from source requires a C compiler. The permissive BSD-3-Clause license makes it suitable for both open-source and commercial projects.

Use it for:

- Coordinate multiple worker processes in a daemon or service that needs kernel-level synchronization without external dependencies.
- Implement fast inter-process message passing for real-time or low-latency applications where socket-based IPC adds overhead.
- Build process pools or job queues that use POSIX semaphores for mutual exclusion and shared memory for efficient data exchange.
- Create named semaphores for inter-process locking in multi-process Python applications running on the same machine.
- Implement producer-consumer patterns using POSIX message queues for decoupled process communication.

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

posix_ipc provides Python bindings to POSIX inter-process communication primitives—semaphores, shared memory, and message queues—for synchronization and data exchange between processes on Unix-like systems and Windows with Cygwin.

Yes, if you need low-level POSIX IPC primitives for multi-process coordination on Unix-like systems. The package is stable, actively maintained, has no known vulnerabilities, and carries a permissive license. Install friction is moderate due to C compilation, but pre-built wheels cover common platforms. Not suitable if you need Windows support without Cygwin or if you prefer higher-level abstractions like multiprocessing or queue modules.

## Install

pip install posix-ipc
uv add posix-ipc
poetry add posix-ipc

## Installing posix-ipc

Before you install: Medium install friction due to C extension compilation required across multiple platforms. Pre-built wheels are available for common Python versions and architectures, reducing friction for standard setups. Maintenance is active with recent releases.

License in practice: BSD-3-Clause permissive license allows use in both open-source and proprietary projects with minimal restrictions; you must include the license text and acknowledge the authors.

Quickstart:

pip install posix-ipc

import posix_ipc

# Create a semaphore
sem = posix_ipc.Semaphore('/my_sem', flags=posix_ipc.O_CREX)
sem.acquire()
sem.release()

Requires a POSIX-compliant system (Unix, Linux, macOS, or Windows with Cygwin ≥ 1.7); C compiler needed if building from source rather than using pre-built wheels.

Verify before relying:

- Whether the package works with Python versions older than those with pre-built wheels (description mentions Python 3 compatibility but requires_python is unspecified).
- Current state of Windows + Cygwin support and whether pre-built wheels are available for that platform.
- Exact Python version range supported beyond the wheel evidence.

## Package facts

- License: BSD-3-Clause (permissive)
- Python support: unspecified
- Install friction: medium
- Maintenance: active
- Downloads: 448.3K/month (top 15,000 on PyPI)
- Known vulnerabilities: none known

## Tags

posix ipc semaphores shared memory, inter-process communication python, posix message queues, cross-process synchronization, ipc primitives unix linux, shared memory python binding, posix realtime extensions, ipc, posix, multiprocessing

[View on SkillFed](https://skillfed.io/packages/posix-ipc) · [View on PyPI](https://pypi.org/project/posix-ipc/)