Skip to main content

POX

POX is an open-source Python-based software platform for rapid development and prototyping of Software Defined Networking (SDN) control applications, originally distributed as part of the NOX/POX controller family.

  • SDN controller framework (network control plane) implemented in Python for OpenFlow-based environments.
  • Supports rapid prototyping of network control logic such as learning switches, routing, and flow management (SDN application development).
  • Modular architecture with loadable components for packet processing, topology discovery, and controller services (controller extensibility).
  • Designed for experimentation, research, and teaching of SDN concepts and OpenFlow behavior (network research/education tooling).
  • Runs on commodity hardware and interfaces with OpenFlow-compatible switches and emulators (OpenFlow interoperability).

More About POX

POX is a Python-based SDN controller platform designed for building, testing, and demonstrating OpenFlow control applications. It originated as part of the NOX family of controllers and is distributed by the NOX Repo project, which provides a common code base and documentation for both NOX (C++) and POX (Python). POX targets scenarios where ease of development and experimentation with SDN logic is a primary requirement, including labs, proofs of concept, and instructional environments.

The platform implements an SDN controller (network control plane) that communicates with OpenFlow-compatible switches using the OpenFlow protocol. Within this controller, POX exposes a modular event-driven framework (application framework) where developers write Python components that subscribe to network events, such as switch connections, port status updates, and packet-in messages. These components can then install, modify, or remove flow entries on switches, allowing customized forwarding behavior, access control, basic routing, or other policy enforcement.

POX provides a set of bundled components and example applications (controller modules) that illustrate core SDN use cases. These include learning switch behavior, spanning tree control, simple load balancing, and basic routing (network control applications). The controller also includes utilities for topology discovery and link-state awareness where supported by the underlying OpenFlow devices (network topology management). Through its Python APIs, POX allows direct access to OpenFlow messages and headers, which supports low-level experimentation with protocol behavior and controller-to-switch interactions.

In enterprise and institutional contexts, POX is commonly used in lab networks, research testbeds, and academic courses on SDN and programmable networks (research and education tooling). It works with OpenFlow-capable physical switches as well as software-based platforms and emulators that expose OpenFlow interfaces (OpenFlow device integration). This makes it suitable for validating SDN concepts, prototyping new control applications before porting them to other controllers, or building reproducible classroom exercises.

Architecturally, POX follows an event-driven model (controller architecture), where core services handle incoming OpenFlow events and dispatch them to subscribed modules in a defined order. Modules can be loaded or unloaded at startup via configuration, enabling tailored controller stacks for specific experiments or teaching scenarios (modular extensibility). The project is positioned in the SDN tooling and controller category, with a focus on accessibility for developers who prefer Python and require a controller that is straightforward to inspect, modify, and extend for OpenFlow-based networks.