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

still a working view ended · each leads to its entry below

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

  1. Software-defined networking (introduction, Concept, History, SDN control plane), Wikipedia
  2. Active networking, Wikipedia
  3. OpenFlow (introduction, History), Wikipedia
  4. ONOS (introduction, History), Wikipedia
  5. OpenDaylight Project (introduction, History), Wikipedia
  6. 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.

  1. 1995-2002

    Active networking

    How can new network services be deployed without upgrading every router?

    Fly to its tower in Nousfarer

  2. 2005-Present

    Control-Data Plane Separation

    Should routing decisions be centralized or distributed?

    Fly to its tower in Nousfarer

  3. 2008-Present

    Controller Platforms

    How can network control be structured as software?

    Fly to its tower in Nousfarer

  4. 2008-Present

    OpenFlow

    How can a controller program a switch uniformly?

    Fly to its tower in Nousfarer

  5. 2009-Present

    Network Virtualization and Overlays

    How can many tenants share one physical network?

    Fly to its tower in Nousfarer

  6. 2014-Present

    Programmable Data Planes

    How can forwarding hardware be programmed directly?

    Fly to its tower in Nousfarer

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.

Active networkingControl-Data Plane SeparationController PlatformsOpenFlowNetwork Virtualization and OverlaysProgrammable Data Planes

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.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

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 Networking

Related fields

Fields its ideas are linked to

More in Networks

See where Software Defined Networking sits on the Map of Human Knowledge