- Atlas
- Computer Science
- Software Defined Networking
Software Defined Networking
Software Defined Networking (SDN) is the idea that a network's control logic—the rules deciding where traffic goes—should be separated from the devices that actually forward the traffic, and that this control logic should run as software on general-purpose computers.
6 frameworks, from 1995 to today · Networks · Computer Science
Overview
Software Defined Networking (SDN) is the idea that a network's control logic—the rules deciding where traffic goes—should be separated from the devices that actually forward the traffic, and that this control logic should run as software on general-purpose computers1. In a traditional router or switch, the two are fused: each box runs its own routing protocol, builds its own view of the network, and forwards packets according to that view. SDN pulls the decision-making out of the boxes and into a program, ideally a single program with a global view of the whole network1. What is at stake is control: who gets to decide how packets move, how quickly a network can be reconfigured, and whether network behavior can be programmed as easily as any other software. The history of SDN is a story of researchers trying to make networks programmable, of an industry slowly accepting a split between control and forwarding, and of the pendulum swinging back toward putting programmability inside the forwarding hardware itself.
Programmable Networks and Active Networks
The ambition to make networks programmable predates the term SDN by more than a decade. In the mid-1990s, a group of researchers—associated with DARPA-funded work in the United States—proposed active networks, in which packets could carry code that routers would execute, or in which users could inject custom processing into network nodes. The motivating problem was the difficulty of deploying new network services: adding a new protocol or a new in-network function meant upgrading every router, a slow and expensive process. Active networks imagined a network where new behavior could be introduced by sending programs to the nodes2.
The idea attracted attention but also resistance. Executing arbitrary code inside routers raised serious security and performance concerns, and the approach never reached wide deployment. Its lasting contribution was the question it posed: how can a network be made to do new things without replacing its hardware? The answer that eventually won was less radical—separate the control software from the forwarding hardware, rather than letting packets carry programs.
Separating the Control and Data Planes
The conceptual foundation of SDN is the split between the control plane (the logic that decides where traffic should go) and the data plane (the hardware that actually moves packets)1. In conventional routers these are bundled together. The idea of separating them was articulated in research on programmable networks in the early 2000s, and it crystallized in a 2005 paper by Albert Greenberg and colleagues at AT&T on a network-management architecture called 4D, which argued for a logically centralized decision element with a global view. Around the same time, researchers at Stanford, including Nick McKeown and Scott Shenker, were pushing the same direction, motivated by the difficulty of experimenting with new protocols on production networks.
The case for separation was practical. A single logical controller with a global view could compute routes and policies that no distributed protocol could easily achieve, and could change them quickly1. The forwarding devices could become simpler, cheaper, and interchangeable. The obstacle was that no standard existed for a controller to talk to a switch, so each vendor's hardware spoke its own language.
OpenFlow and the Standard Interface
The breakthrough came in 2008, when McKeown and colleagues at Stanford, with collaborators at Berkeley and other institutions, proposed OpenFlow. OpenFlow defined a standard protocol by which a controller could program the forwarding table of a switch—adding, modifying, and removing flow entries that matched packet headers and specified actions3. Crucially, it could be implemented on existing commercial switches with modest firmware changes, which meant researchers did not need new hardware to experiment.
OpenFlow made the control-data separation concrete and testable. A controller could now install rules across many switches, and the switches would forward accordingly. The first large-scale demonstration came in 2010, when Google announced it had used OpenFlow to manage traffic on its internal backbone network, showing that the idea worked at production scale. The Open Networking Foundation, founded in 2011, took up stewardship of the OpenFlow standard and promoted SDN more broadly1.
Controller Platforms and the Operating-System Analogy
With a standard interface in place, the next problem was building the controller itself. Early controllers were simple programs, but as SDN matured, researchers built controller platforms: software frameworks that sit between the network applications and the switches, providing a common view of the network and a programming interface. The analogy often drawn was to an operating system: the controller platform is the OS, the switches are the hardware, and network applications are the programs running on top.
Several platforms became influential. NOX, developed at Nicira (a company founded by Martin Casado and colleagues, later acquired by VMware), was among the first. POX was a Python-based successor aimed at research and teaching. Floodlight, an open-source Java controller, and Ryu, a component-based framework, followed. ONOS, developed with backing from AT&T and others, targeted carrier-grade networks with high availability requirements4. OpenDaylight, a collaborative open-source project launched in 2013 under the Linux Foundation, became a broad platform for SDN and network functions5. These platforms differed in language, architecture, and target scale, but all embodied the same principle: network behavior should be written as software against a common interface.
Network Virtualization and Overlays
While OpenFlow addressed how a controller programs physical switches, a parallel line of work addressed a different problem: how to give many tenants their own logical networks on shared physical infrastructure. This is network virtualization, and its most influential form was the overlay.
The key insight, developed by Casado and colleagues in work that led to Nicira, was that a network could be virtualized by encapsulating packets and managing the virtual topology in software, without requiring changes to the underlying physical network. The overlay—a logical network built on top of the physical one—could be created and torn down quickly, and each tenant could have its own addressing and policy. This approach became the basis for large-scale data-center networking, where many virtual machines and tenants share physical switches. VXLAN, a standard encapsulation scheme for such overlays, was developed with contributions from VMware, Cisco, and others and published as an IETF draft in 2011. Overlay networking showed that SDN's separation of control from forwarding could be applied not just to physical switches but to entire virtual topologies.
Programmable Data Planes and the Return of the Hardware
A persistent limitation of OpenFlow-era SDN was that the data plane—the switch hardware—was fixed. OpenFlow could program which rules were installed, but the set of match fields and actions was defined by the standard and constrained by the switch's capabilities. Researchers who wanted new forwarding behavior had to wait for new hardware or new protocol versions.
This changed with the rise of programmable data planes. The most prominent example is P4, a language for programming packet processors, introduced in 2014 by Pat Bosshart and colleagues at Barefoot Networks and collaborating institutions. P4 let network designers specify how a switch parses packets and what actions it takes, rather than choosing from a fixed menu6. This required new hardware—programmable switching chips—and companies such as Barefoot Networks (later acquired by Intel) built them. The development echoed the original active-networks ambition but in a disciplined form: programmability inside the data plane, specified in a language with a well-defined semantics, rather than arbitrary code injected into routers.
Programmable data planes shifted the balance of the SDN story. The control-data separation remained, but the data plane was no longer a passive, fixed target; it could itself be programmed. This made possible in-network functions—telemetry, load balancing, custom forwarding—that had previously required separate appliances.
The Present: Multiple Paths Forward
Today SDN is less a single architecture than a family of approaches that share the control-data separation. In data centers, overlay networking and software controllers are standard practice. In wide-area networks, centralized traffic engineering—exemplified by Google's use of OpenFlow on its backbone—has been adopted by several large operators1. Controller platforms such as ONOS and OpenDaylight serve carrier and enterprise deployments, while cloud providers build their own. Programmable data planes, through P4 and programmable switching silicon, have become a distinct and active research and commercial area.
The open questions are the ones the field has carried from the beginning. How centralized should control be, given the risks of a single point of failure and the latency of consulting a remote controller1? How can SDN principles be extended to networks owned by many parties, where no single controller has authority? And how should the programmability of the data plane be governed, so that custom forwarding does not become a source of fragility or security holes? The history of SDN is the history of a simple idea—separate the decision from the forwarding—and of the many forms that idea has taken as hardware, standards, and software have changed around it.
References
- Software-defined networking (introduction, Concept, History, SDN control plane), Wikipedia
- Active networking, Wikipedia
- OpenFlow (introduction, History), Wikipedia
- ONOS (introduction, History), Wikipedia
- OpenDaylight Project (introduction, History), Wikipedia
- P4 (programming language), Wikipedia
The frameworks of Software Defined Networking
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1995-2002
Active networking
How can new network services be deployed without upgrading every router?
- 2005-Present
Control-Data Plane Separation
Should routing decisions be centralized or distributed?
- 2008-Present
- 2008-Present
- 2009-Present
Network Virtualization and Overlays
How can many tenants share one physical network?
- 2014-Present
Programmable Data Planes
How can forwarding hardware be programmed directly?
How the ideas connect
Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.
Controller Platforms grew out of Control-Data Plane Separation
Once control was separated from forwarding, the controller itself had to be built, and controller platforms like NOX grew directly out of the 4D and Stanford separation work. Martin Casado, who worked on 4D-style architectures, co-founded Nicira and developed NOX as the software embodiment of the centralized control element.
Carried by Martin Casado; NOX (2008).
OpenFlow grew out of Control-Data Plane Separation
OpenFlow was created to supply the missing standard interface between a separated controller and switches, making the control-data split concrete. Nick McKeown and colleagues at Stanford, who had been pushing the separation idea, designed OpenFlow as its enabling protocol.
Carried by Nick McKeown; OpenFlow (2008).
Control-Data Plane Separation influenced by Active networking
Active networking's goal of making networks programmable without replacing hardware carried into the 4D work by Greenberg et al., which proposed a logically centralized control element. The 4D authors cited active networks as prior work and reframed programmability as separating control from forwarding rather than executing code in packets.
Carried by Albert Greenberg; 4D (2005).
Network Virtualization and Overlays influenced by Control-Data Plane Separation
Network virtualization applied the control-data separation to logical topologies, with Martin Casado and colleagues at Nicira developing overlay approaches that managed virtual networks in software. Their work built on the centralized-control ideas of the separation framework.
Carried by Martin Casado; Nicira.
Controller Platforms influenced by OpenFlow
OpenFlow's standard switch interface gave controller platforms a common protocol to program, and early controllers like NOX were built around OpenFlow. The availability of OpenFlow shaped the architecture of subsequent platforms such as Floodlight and ONOS.
Carried by OpenFlow (2008); NOX (2008).
Programmable Data Planes influenced by OpenFlow
OpenFlow's fixed match-action menu limited what controllers could program, and P4 was designed to overcome this by letting designers specify the parser and actions themselves. The P4 authors, including Pat Bosshart, framed their work as extending OpenFlow-style programmability into the data plane.
Carried by Pat Bosshart; P4 (2014).
Programmable Data Planes revived Active networking
Programmable data planes deliberately revived the active-networks ambition of putting programmability inside forwarding hardware, but in a disciplined form with a well-defined language. The P4 work echoed that earlier goal while rejecting arbitrary code injection.
Carried by Pat Bosshart; P4 (2014).
Beyond the field
Where Software Defined Networking's ideas came from in other fields, and what they led to there: the strongest 12 of 18 links.
Control-Data Plane Separation led to Software-Defined Networking in Networks
Control-data plane separation is the defining architectural principle from which software-defined networking was built; the OpenFlow work of 2008 made the separation programmable and turned it into SDN.
Carried by Nick McKeown; OpenFlow (2008).
Control-Data Plane Separation led to Software-Defined Networking in Routing And Internetworking
Software-defined networking is the generalisation of control-data plane separation into a programmable, centrally controlled architecture. The earlier separation of signalling from forwarding is the core idea SDN extended with open interfaces and centralised controllers.
Control-Data Plane Separation influenced Software-defined networking in Network Protocols
Control-data plane separation is the defining architectural principle that SDN took up and generalised into a programmable, centrally controlled network. SDN's central controller is the direct extension of the separated control plane.
Active networking revived by Software-Defined Networking in Networks
Active networking of the 1990s proposed programmable in-network computation and was largely abandoned; the SDN movement of 2008 deliberately revived its goal of programmable network control, though with a centralised controller rather than per-packet code.
Carried by David Tennenhouse.
Active networking influenced by Packet Switching in Networks
Active networking was proposed as a way to make packet-switched networks programmable, letting routers execute user-supplied code on packets. Its designers built directly on the store-and-forward packet model, adding computation at forwarding nodes.
Carried by David Tennenhouse; David Wetherall.
Active networking revived by Software-Defined Networking in Routing And Internetworking
Software-defined networking deliberately revived the active-networking goal of programmable network nodes after that movement faded around 2002. SDN's proponents cited active networking as a precursor and adopted its aim of injecting custom behaviour into the network, though with centralised control rather than in-network code.
Active networking influenced Clean-Slate Architecture in Network Architecture
Active networking's idea of programmable in-network computation was taken up by clean-slate designers, who inherited its questions about where programmability belongs while rejecting its per-packet execution model.
Carried by David Tennenhouse.
Active networking influenced Software-Defined Networking in Network Architecture
Active networking's programme of making networks programmable was revived by SDN, which adopted its goal of in-network computation while replacing per-packet code with centralized control.
Carried by David Tennenhouse.
Active networking revived by Software-defined networking in Network Protocols
Software-defined networking revived the active-networking ambition of programmable network nodes after that movement faded around 2002. SDN proponents explicitly cited active networking as a precursor whose programmability goal they pursued with a separated controller.
Control-Data Plane Separation influenced Clean-Slate Architecture in Network Architecture
Control-data plane separation, developed in the same period, gave clean-slate architecture a concrete mechanism for centralized network-wide policy, and several clean-slate designs adopted it.
Control-Data Plane Separation influenced Low-latency data-center congestion control in Congestion Control
Data-center congestion control exploits control-data plane separation, using centralized or logically centralized controllers and switch telemetry to set rates and thresholds. The separation made fine-grained, network-wide rate coordination feasible.
OpenFlow influenced Segment Routing in Routing And Internetworking
Segment Routing was developed in the wake of OpenFlow's flow-based programming model, and early work presented it as a way to achieve traffic steering without OpenFlow's per-flow state in every switch. The OpenFlow experience shaped its design goals.

Software Defined Networking is a planet in Nousfarer
Its city has a tower for each of these 6 frameworks. Land, walk in, and climb one concept at a time.
Land on Software Defined NetworkingRelated fields
Fields its ideas are linked to
- Network Architecture 6 links
- Routing And Internetworking 4 links
- Network Protocols 3 links
- Networks 3 links
- Congestion Control 1 link
- Operating Systems 1 link
More in Networks
- Congestion Control
- Network Architecture
- Network Protocols
- Networks
- Peer To Peer And Content Delivery
- Routing And Internetworking
- Wireless Networks
See where Software Defined Networking sits on the Map of Human Knowledge