synchronicity
Export blocking and async library versions from a single async implementation
Decision gist · record as of 2026-08-14
Yes. Synchronicity fills a genuine gap in Python async library design—enabling a single codebase to serve both sync and async users without duplication. Low install friction, permissive license, active maintenance, no known vulnerabilities, and top-1000 popularity suggest it is stable and trusted. Install it if you are building a library that needs to support both calling conventions or if you want to avoid the complexity of maintaining parallel sync and async implementations.AI-flagged interpretation of the facts on this page — verify before relying
Before you install
- Requires Python 3.10 or later.
- Low install friction with a single lightweight dependency (typing-extensions).
- Active maintenance with a recent release.
License · maintenance · safety
permissive license (permissive) — Licensed under Apache License 2.0 (permissive), allowing commercial and private use with minimal restrictions.
last release 2026-06-18 (57 days)
0 known vulnerabilities (OSV.dev, 2026-08-14) · 53,917,432 downloads/mo, #549 on PyPI
Alternatives
Verify before relying
pip install synchronicity
from synchronicity import Synchronizer
import asyncio
synchronizer = Synchronizer()
@synchronizer.wrap
async def f(x):
await asyncio.sleep(1.0)
return x**2
# Synchronous call blocks until result
ret = f(42)
# Async call via .aio property
async def g():
ret = await f.aio(42)
return ret- Whether the separate event loop thread adds measurable overhead for high-frequency calls.
- Thread-safety guarantees when wrapped classes maintain mutable state across sync and async calls.
- Performance characteristics when wrapping classes with many methods or complex initialization.
What it is and what it does
Synchronicity solves the problem of maintaining both synchronous and asynchronous APIs for the same underlying async code without duplicating implementation. It provides a `Synchronizer` class that wraps async functions, generators, and classes, running them on a dedicated event loop in a separate thread. Wrapped functions expose two interfaces: calling them directly blocks until the result is available (synchronous use), while calling the `.aio` property on the wrapper executes them asynchronously on the synchronizer's own event loop.
This is particularly useful for libraries that want to support both blocking and async callers without code duplication, and for preserving state across multiple calls (like a database connection that needs to stay open). The separate event loop design also isolates library execution from user code, preventing one side from blocking the other's event loop—a common pitfall in async Python.
Use it for
- Build a database client library with persistent connections that works in both sync and async contexts without duplicating connection logic.
- Wrap async generator functions to expose them as regular generators for synchronous callers while keeping async iteration available.
- Create a library that supports both blocking scripts and async frameworks from a single async implementation.
- Dispatch multiple async operations from a blocking context using `_future=True` to resolve them roughly in parallel.
- Synchronize context manager classes (with `__aenter__` / `__aexit__`) for use in both `with` and `async with` statements.
- Isolate library async code on its own event loop to prevent accidental blocking calls from locking up user code's event loop.
Worth the install?
AI-flagged interpretation of the facts on this page. Verify before relying on it.
Yes.
Synchronicity fills a genuine gap in Python async library design—enabling a single codebase to serve both sync and async users without duplication. Low install friction, permissive license, active maintenance, no known vulnerabilities, and top-1000 popularity suggest it is stable and trusted. Install it if you are building a library that needs to support both calling conventions or if you want to avoid the complexity of maintaining parallel sync and async implementations.
Install
synchronicity on PyPI
Before you install
Low install friction with a single lightweight dependency (typing-extensions). Active maintenance with a recent release.
Requires Python 3.10 or later.
License in practice
Licensed under Apache License 2.0 (permissive), allowing commercial and private use with minimal restrictions.
Quickstart
pip install synchronicity
from synchronicity import Synchronizer
import asyncio
synchronizer = Synchronizer()
@synchronizer.wrap
async def f(x):
await asyncio.sleep(1.0)
return x**2
# Synchronous call blocks until result
ret = f(42)
# Async call via .aio property
async def g():
ret = await f.aio(42)
return retVerify before relying
- Whether the separate event loop thread adds measurable overhead for high-frequency calls.
- Thread-safety guarantees when wrapped classes maintain mutable state across sync and async calls.
- Performance characteristics when wrapping classes with many methods or complex initialization.
Package facts
| License | permissive license permissive |
| Python support | Supports the current Python release >=3.10 |
| Install friction | Low. Pure-Python wheel |
| Runtime dependencies | 1 packagetyping-extensions |
| Maintenance | Actively maintained 57 days since the last release |
| First released | |
| Downloads | 53,917,432 / month, #549 on PyPI 30-day window, as of 2026-08-14 |
| Known vulnerabilities | None known OSV.dev, checked 2026-08-14 |
| Classifiers | License :: OSI Approved :: Apache Software LicenseOperating System :: OS IndependentProgramming Language :: Python :: 3 |
Evidence: synchronicity-0.12.5-py3-none-any.whl
Tags
Let your AI agent find packages like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 14,416 PyPI packages by what they can do, searchable in plain language.
wish › “dual sync async interface”
- synchronicityWraps async functions, generators, and classes to expose both…
- unasyncTransforms asynchronous Python code into synchronous code during…
- caldavA CalDAV (RFC4791) client library for Python that lets you create,…
Give your agent the search over MCP, or paste the wish link into any chat.
Similar packages
Transforms asynchronous Python code into synchronous code during package build, enabling maintainers to generate both async and sync APIs from a single async source.
Decorator-based library that runs async functions in an ambient event loop and regular functions in thread or process pools, returning awaitable futures that combine asyncio and concurrent.futures semantics.
However, dormancy since 2021-10-21 and unspecified Python version support mean you should verify compatibility with your target Python version before committing.
Duet is a lightweight async library that wraps Future objects to enable async/await syntax around APIs that return futures, such as gRPC, while supporting re-entrant event loops.
Not recommended as a general-purpose async framework.
Provides ASGI base libraries including sync-to-async and async-to-sync function wrappers, server base classes, and a WSGI-to-ASGI adapter for bridging synchronous and asynchronous Python web code.
Install it if you're building or migrating to async Python web applications, especially with Django or Channels, or if you need to bridge sync and async code…
Provides a thread-safe queue with both synchronous and asynchronous interfaces for passing data between classic threaded code and asyncio tasks.
Wraps psutil to allow multiple independent instances in the same process by isolating global state, solving the library's inherent limitation of maintaining state through global variables.
However, if you only use psutil once per process, this wrapper adds unnecessary indirection—use psutil directly instead.
See also futurist · threadloop · greenback · syncer