FastADS is a native-powered, async-first TwinCAT ADS client for Python, built for high-performance industrial communication.
FastADS is a modern, high-performance ADS client for Beckhoff TwinCAT systems, built for industrial Python applications that need speed, scalability, and clean developer ergonomics. Together with our proprietary fastads-core.dll, it is engineered for scenarios where the standard pyads stack backed by Beckhoff adslib.dll becomes the bottleneck.
It is built for machine connectivity, test systems, industrial analytics, gateways, orchestration layers, and custom automation software where ADS communication must be both fast and maintainable.
FastADS is built for selected industrial Python projects where the standard pyads and adslib path becomes the limiting factor. The goal is a stronger internal option when throughput, batching, subscriptions, and full-stack PLC integration matter more than compatibility.
Timings depend on CPU performance and system load.
FastADS combines an async-first Python API with a native C core so Python applications get fast symbol access, efficient batch communication, and low-overhead concurrent ADS workloads.
Instead of forcing procedural ADS plumbing, FastADS uses a modern object-oriented API with typed subscriptions, RPC integration, device control helpers, and raw ADS access when experts need it.
Prepared symbol sets, native scalar buffers, pooling, and parallel connections support large symbol sets and long-running services, with bundled Windows, Linux, and macOS binaries so target machines do not need to build the native core.
FastADS is meant to feel usable in production Python, not just benchmark well. The native client exposes the same core ideas across async and sync flows: symbols, plans, subscriptions, services, and workflow-aware operations.
The async client keeps symbol access and compiled plans readable even when communication volume grows.
import asyncio
from fastads import AdsClient, types
async def main():
async with AdsClient(
host="192.168.1.100",
target_net_id="192.168.1.100.1.1",
parallel_connections=4,
) as client:
counter = client.symbol("MAIN.counter", types.DInt)
print(await counter.read())
await counter.write(123)
plan = await client.plan(
(
("MAIN.counter", types.DInt),
("MAIN.enabled", types.Bool),
)
)
print(await plan.read())
asyncio.run(main())Typed service binding stays short and approachable when you want a clean PLC-facing API instead of raw symbol plumbing.
import asyncio
from fastads import AdsClient, service, types
@service("MAIN.math")
class MathService:
async def add(self, left: types.DInt, right: types.DInt) -> types.DInt:
raise NotImplementedError
async def main():
async with AdsClient(
host="192.168.1.100",
target_net_id="192.168.1.100.1.1",
) as client:
math = client.bind(MathService)
print(await math.add(20, 22))
asyncio.run(main())If you can choose freely, FastADS is the stronger general-purpose option. It brings the highest performance while also covering typed RPC, subscriptions, compiled plans, raw ADS access, and long-running industrial Python workloads.
Pyads-Agile remains the right choice when compatibility is the deciding constraint. Its main advantage is staying close to pyads and the Beckhoff adslib runtime while adding cleaner TwinCAT-oriented ergonomics.
If there is no compatibility constraint, start with FastADS. It already covers RPC, subscriptions, plans, and service-style integrations, while giving you more throughput headroom for real production workloads.
Pyads-Agile is strongest when the application already speaks pyads and the goal is to improve TwinCAT ergonomics without changing the underlying compatibility model too aggressively.
Where Beckhoff adslib behavior, qualification history, installed tooling, or deployment expectations are part of the acceptance criteria, Pyads-Agile keeps you on the familiar runtime path.
For gateways, analytics, orchestration layers, regression rigs, and symbol-heavy machine services, FastADS is the default recommendation even when you also need RPC and advanced PLC integration patterns.
Tell us what you are building, where the current blocker is, and what the target architecture should support.