Skip to content

BGP Ecosystem

Jump to bottom
Thomas Mangin edited this page Nov 15, 2025 · 6 revisions

BGP Ecosystem - Alternative Implementations

Note: This page compares OTHER BGP implementations in the open source ecosystem. For ExaBGP documentation, see the Home page.

Table of Contents

Overview

The BGP ecosystem offers a rich variety of open source implementations, each designed for different use cases and preferences. This guide helps you choose the right BGP implementation for your needs.

Key Distinction: Understand the difference between:

  • Full routing daemons (BIRD, FRR, OpenBGPD) - Manage routing tables, install routes
  • Programmatic BGP tools (ExaBGP, GoBGP library, CoreBGP) - Automation, API-driven
  • Monitoring tools (pmacct, YABGP) - Collection and analysis

⚠️ Performance Benchmark Caveat: Performance benchmarks referenced in this document are from 2021-2022 and may not reflect current performance. Software performance can change significantly over 3-4 years, especially for actively developed projects. Treat benchmark data as historical reference only.

When to Use What - Quick Decision Guide

Your Need Options Characteristics
IXP Route Server BIRD Powerful policy language, widely used in IXPs
Full Routing Daemon FRRouting, BIRD, OpenBGPD Complete protocol suites with different focuses
DDoS Mitigation ExaBGP, FRRouting, BIRD, GoBGP FlowSpec support available in multiple implementations
Anycast Services ExaBGP, GoBGP Simple API integration, health check support
Kubernetes/Cloud GoBGP, ExaBGP Cloud-native design options (gRPC or STDIN/STDOUT)
Security Focus OpenBGPD OpenBSD security focus, auditable codebase
Network Automation ExaBGP, GoBGP, CoreBGP Programmable interfaces, scriptable
BGP Monitoring pmacct/pmbmpd, YABGP BMP collection and BGP message analysis
Java Environment freeRouter Full-featured router in Java

Production-Ready Implementations

BIRD

Language: C Website: http://bird.network.cz/ Status: Mature, Active

Description: A routing daemon offering powerful filtering capabilities and designed for policy-heavy environments like IXPs and route servers.

Key Features:

  • Multiple routing tables
  • Powerful filtering/policy language
  • IPv4 and IPv6 support
  • BGP, OSPF, RIP, Babel, BFD, RPKI
  • Route server capabilities
  • FlowSpec support (modern versions)

Use Cases:

  • IXP route servers
  • Large routing tables
  • Policy-heavy environments

FRRouting

Language: C Website: https://frrouting.org Status: Mature, Active

Description: A full-featured open-source routing solution, successor to the Quagga project.

History:

  • GNU Zebra (abandoned 2005) → Quagga → FRRouting (April 2017 fork)
  • Created to enable more open and faster development
  • Cumulus Linux 3.4+ replaced Quagga with FRR

Key Features:

  • Full routing protocol suite (BGP, OSPF, ISIS, RIP, EIGRP, PIM, BFD)
  • IPv4 and IPv6 support
  • MPLS support
  • BGP FlowSpec support (modern versions)
  • VRF support
  • Graceful restart
  • Route maps and prefix lists

Use Cases:

  • Enterprise routers
  • Data center networking
  • ISP routing infrastructure
  • Linux-based routers

ExaBGP

Language: Python Website: https://github.com/Exa-Networks/exabgp Status: Mature, Active

Description: A unique, Python-based tool focused on programmatic BGP peering and network automation, rather than being a full routing daemon. "The BGP swiss army knife of networking."

Key Features:

  • Simple API (STDIN/STDOUT)
  • BGP FlowSpec (pioneered open source implementation, now also in GoBGP/FRR/BIRD)
  • IPv4, IPv6, MPLS VPN, EVPN, BGP-LS support
  • JSON and text encoders
  • External process model
  • No RIB/FIB manipulation - pure protocol implementation

Philosophy:

  • ExaBGP does NOT install routes in kernel routing table
  • External processes handle route installation via API
  • Focus on BGP protocol and programmability
  • Language-agnostic integration (Python, Bash, Go, Ruby, any language)

Performance Characteristics:

  • Python implementation
  • Not designed for full routing table
  • Designed for route injection/collection
  • Scales to Facebook/Meta level (Katran L4LB)

Use Cases:

  • DDoS mitigation with FlowSpec
  • Anycast service announcement and management
  • Dynamic load balancing
  • Route injection and advertisement
  • Network automation
  • BGP testing and simulation
  • Route monitoring and collection
  • Automation and orchestration
  • BGP as an API
  • Integration with existing infrastructure

For complete ExaBGP documentation, see:

GoBGP

Language: Go Website: https://osrg.github.io/gobgp/ Status: Mature, Active

Description: An open source BGP implementation designed from scratch for modern environments and implemented in Go. Supports modern BGP features and cloud-native deployments.

Key Features:

  • Modern Go codebase
  • gRPC API
  • BGP FlowSpec support
  • MRT support
  • BMP (BGP Monitoring Protocol) support
  • Graceful restart
  • Cloud-native design
  • Can be used as library or daemon

Performance Characteristics:

  • Multi-core support
  • Cloud-native design

Use Cases:

  • Cloud-native environments
  • Container networking
  • Kubernetes integration
  • Automation via gRPC API
  • Modern application integration

OpenBGPD

Language: C Website: https://www.openbgpd.org/ Status: Mature, Active (OpenBSD project)

Description: The routing daemon developed and supported by the OpenBSD project, known for its focus on security, simplicity, and clear configuration.

Key Features:

  • Security-focused design
  • Simple configuration syntax
  • IPv4 and IPv6 support
  • Prefix filtering
  • AS path manipulation
  • Route reflector support
  • Portable to other BSDs and Linux

Performance Characteristics:

  • Single process architecture
  • Focus on correctness and security

Use Cases:

  • Security-conscious deployments
  • OpenBSD systems
  • Simple BGP setups

Emerging Implementations

RustyBGP

Language: Rust Website: https://github.com/osrg/rustybgp Status: Experimental

Description: Mission to develop a high-performance and safe BGP implementation. An experiment to implement aged and rusty BGP protocol in a modern language.

Key Features:

  • Rust memory safety
  • Multi-core design
  • gRPC APIs (GoBGP compatible)
  • High performance potential

Performance Characteristics:

  • Uses all CPU cores
  • Multi-core utilization

Key Characteristics:

  • Rust memory safety
  • GoBGP API compatible
  • Experimental status
  • Limited policy support

bio-routing

Language: Go Website: https://github.com/bio-routing/bio-rd Status: Active

Description: A project to create a versatile, fast and reliable routing daemon in Go. bio = BGP + IS-IS + OSPF.

Key Features:

  • Multi-protocol (BGP, IS-IS, OSPF)
  • Modern Go implementation
  • Designed for performance
  • Modular architecture

Key Characteristics:

  • Modern Go codebase
  • Multi-protocol support
  • Well-architected design
  • Active development

CoreBGP

Language: Go Website: https://github.com/jwhited/corebgp Status: Active

Description: A BGP library written in Go that implements the BGP FSM with an event-driven, pluggable model.

Important: This is a library, not a daemon. It:

  • Does NOT manage RIB
  • Does NOT send UPDATE messages
  • User controls all behavior via plugins

Use Cases:

  • Building custom BGP applications
  • BGP-enabled services
  • Research and experimentation

Key Characteristics:

  • Pluggable architecture
  • Full control for developers
  • Modern Go library
  • Requires custom implementation

Language-Specific Options

If You Are a Go Person

Go implementations available:

  1. GoBGP - https://github.com/osrg/gobgp

    • Daemon with gRPC API
    • Full BGP feature set
    • Cloud-native design

  2. bio-routing - https://github.com/bio-routing/bio-rd

    • Multi-protocol (BGP, IS-IS, OSPF)
    • Well-architected
    • Active development

  3. CoreBGP - https://github.com/jwhited/corebgp

    • Library for building custom BGP apps
    • Event-driven plugin model

If You Are a C Person

C implementations available:

  1. BIRD - http://bird.network.cz/

    • IXPs and route servers
    • Powerful policy language

  2. FRRouting - https://frrouting.org

    • Full routing protocol suite
    • Modern development
    • Enterprise/ISP use

  3. OpenBGPD - https://www.openbgpd.org/

    • Security-focused
    • OpenBSD quality
    • Simple configuration

If You Are a Rust Person

Rust implementations available:

  1. RustyBGP - https://github.com/osrg/rustybgp

    • Multi-core support
    • Experimental

  2. bgpd-rs - https://github.com/thepacketgeek/bgpd-rs

    • Educational/experimental
    • Based on bgp-rs library

  3. bgp-rs - https://github.com/DevQps/bgp-rs

    • Library for BGP parsing
    • Used by bgpd-rs

  4. ZettaBGP - https://docs.rs/zettabgp/latest/zettabgp/

    • Comprehensive library for parsing/composing BGP and BMP
    • 15+ address families (IPv4/IPv6, VPN, EVPN, FlowSpec)
    • For building route reflectors, monitoring systems
    • Library only (not a complete daemon)

If You Are a Java Person

freeRouter - http://www.freertr.org/

  • Full routing protocol suite
  • BGP4, BGP6, OSPF, ISIS, and more
  • P4 integration
  • DPDK support
  • OS-independent packet handling

If You Are a Ruby Person

  1. BGPFeeder - https://github.com/BytemarkHosting/bgpfeeder

    • Lightweight static route distribution
    • Production use at Bytemark Hosting
    • Simple anycast setups

  2. bgp4r - https://github.com/jesnault/bgp4r

    • BGP implementation in Ruby
    • Research before using

If You Are a Perl Person

bgpsimple - Historical interest only

svn checkout http://bgpsimple.googlecode.com/svn/trunk/ bgpsimple-read-only

Note: Google Code is archived. Use modern alternatives.

If You Are an Erlang Person

There are implementations here:

  1. eggpd - https://github.com/ThomasHabets/eggpd

    • BGP implementation in Erlang
    • Experimental

  2. erlang-bgp - https://github.com/brunorijsman/erlang-bgp

    • Start of an implementation
    • Very early stage

If You Are a Haskell Person

hBGP - https://github.com/hdb3/hBGP

  • BGP implementation in Haskell
  • Academic/research use
  • Functional programming approach

Python Ecosystem

ExaBGP - The Swiss Army Knife

Website: https://github.com/Exa-Networks/exabgp

The most popular Python BGP implementation, focused on automation and programmability.

Use Cases:

  • Network automation
  • DDoS mitigation (FlowSpec)
  • Anycast management
  • Load balancing
  • Route injection

See ExaBGP documentation for complete details.

YABGP - Analysis Focus

Website: https://github.com/smartbgp/yabgp

You could have a look at YABGP (which came after ExaBGP):

Description: Yet Another BGP Python Implementation. Can establish BGP connections with routers and receive/parse BGP messages for analysis.

Key Features:

  • BGP message parsing
  • Works with Cisco/Huawei/Juniper routers
  • GNS3 simulator support
  • Analysis-focused

Code Heritage:

  • Borrowed from PyBal (Wikimedia) for FSM/protocol
  • References ExaBGP for message parsing

Use Cases:

  • BGP message analysis
  • Network testing
  • Research and learning

Note: Analysis and testing focused.

BaGPipe-BGP - OpenStack Integration

Website: https://github.com/Orange-OpenSource/bagpipe-bgp Organization: Orange

If you want something which works with OpenStack:

In 2014, multiple projects started experimenting with BGP for OpenStack. Orange released BaGPipe which uses ExaBGP's classes to write their own BGP route injector with a clear focus on OpenStack. Some of their code has been ported back into ExaBGP - Thank you for the help!

Key Features:

  • BGP VPN support
  • OpenStack Neutron integration
  • Based on ExaBGP classes
  • EVPN support

Note: Designed for OpenStack deployments.

Ryu - SDN Framework

Website: https://github.com/osrg/ryu Organization: NTT

If you want something which works with OpenStack but NOT ExaBGP based:

Ok... we got it... no point in getting agitated :-) NTT supports the development of Ryu, which you should have a look at too as it added BGP support in 2014.

Key Features:

  • SDN controller framework
  • BGP support
  • OpenFlow integration

Note: For SDN use cases.

PyBal - Wikimedia Load Balancer

Website: git.wikimedia.org/tree/operations/debs/pybal.git Organization: Wikimedia Foundation

If you want something for your website resilience:

You should look at healthcheck in ExaBGP but as you insist on not using it, the Wikimedia Foundation wrote something cool named PyBal.

Key Features:

  • BGP-based load balancing
  • Health checking
  • Service announcement
  • Production use at Wikimedia

Note: Specific to Wikimedia patterns.

pybgp - Twisted Framework

Website: https://code.launchpad.net/pybgp

ExaBGP is not what I am looking for?

You could check pybgp:

bzr branch lp:pybgp

I am not sure if this project existed when I started ExaBGP or not but I clearly missed it! It does not support many RFCs, but has IPv4 and VPNv4/MPLS. I really like Twisted and use it a lot but did not want a dependency on it for a BGP daemon.

Key Features:

  • Uses Twisted framework
  • IPv4 and VPNv4/MPLS support
  • Limited RFC support

Note: Limited RFC support.

Specialized Tools

pmacct / pmbmpd - BMP Monitoring

Website: https://github.com/pmacct/pmacct

I am looking for a BMP daemon in another language than Python:

We used to have one but... not anymore. The pmbmpd daemon of pmacct can be used to collect BMP messages, which can then be shipped to Kafka.

Key Features:

  • BMP (RFC 7854) collector
  • BGP prefix/update collection
  • NetFlow, IPFIX, sFlow support
  • Kafka integration
  • Production-grade monitoring

Use Cases:

  • BGP monitoring
  • Network telemetry
  • BGP data collection
  • ISP-scale monitoring

Note: Widely used for BGP monitoring.

pbgp-parser - PCAP Analysis

Website: https://github.com/de-cix/pbgp-parser Organization: DE-CIX

I have some PCAP files I need parsing:

You could surely do something with ExaBGP but otherwise pbgp-parser will help you.

Use Cases:

  • PCAP file analysis
  • BGP troubleshooting
  • Traffic analysis

Piranha - Network Monitoring

Website: https://github.com/spale75/piranha

I want to know what is happening on my network:

You could surely do something with ExaBGP and otherwise Piranha can help you.

Use Cases:

  • Network monitoring
  • BGP visibility

BgpKit Parser - MRT Data

Website: https://github.com/bgpkit/bgpkit-parser Language: Rust

MRT/BGP data parser library written in Rust. NOT a BGP daemon - this is a library for parsing BGP data.

Use Cases:

  • BGP data analysis
  • MRT file parsing
  • Research

Note: Useful library for analysis, not a routing daemon.

Performance Notes

⚠️ Important: Performance benchmarks referenced in this document are from 2021-2022 and may not reflect current performance. Software performance can change significantly over 3-4 years. Use as historical reference only.

Different implementations have different performance characteristics:

Multi-Core Support:

  • RustyBGP, GoBGP: Multi-core utilization
  • BIRD, FRRouting, OpenBGPD, ExaBGP: Single-core architecture

Memory and CPU Considerations:

  • Each implementation has different memory and CPU requirements
  • Performance varies based on use case (full table, route injection, monitoring)
  • Benchmark your specific use case before choosing

Implementation Characteristics

By Language

Language Production-Ready Experimental Libraries
C BIRD, FRR, OpenBGPD - -
Python ExaBGP YABGP, PyBal, pybgp BaGPipe, Ryu
Go GoBGP bio-routing CoreBGP
Rust - RustyBGP ZettaBGP, bgp-rs
Java freeRouter - -
Ruby - BGPFeeder, bgp4r -
Erlang - eggpd, erlang-bgp -
Haskell - hBGP -

ExaBGP vs. Full Routing Daemons

ExaBGP Characteristics:

  • Pure BGP protocol implementation (no RIB/FIB manipulation)
  • API-driven architecture (STDIN/STDOUT)
  • Focus on automation and programmability
  • Python ecosystem
  • FlowSpec support (pioneered open source implementation)
  • Health check integration
  • Language-agnostic (any language can use the API)

Full Routing Daemons (BIRD/FRR/OpenBGPD):

  • Complete routing stack with RIB/FIB management
  • Kernel integration and route installation
  • Traditional router replacement
  • Multi-protocol support (OSPF, ISIS, etc.)
  • Optimized for full routing tables
  • System-level integration

Ecosystem Summary

Maturity Levels

Production-Grade (Battle-Tested):

  • ✅ BIRD - IXPs worldwide
  • ✅ FRRouting - Enterprises, ISPs, Linux distros
  • ✅ ExaBGP - Facebook/Meta, ISPs, enterprises
  • ✅ OpenBGPD - OpenBSD community

Production-Ready (Proven):

  • ✅ GoBGP - Cloud deployments
  • ✅ freeRouter - Research networks

Emerging (Active Development):

  • 🔄 RustyBGP - Promising but experimental
  • 🔄 bio-routing - Active development
  • 🔄 CoreBGP - Library for developers

Experimental / Niche:

  • 🧪 YABGP - Analysis focus
  • 🧪 bgpd-rs - Learning project
  • 🧪 Erlang/Haskell implementations

Historical Evolution

1996: GNU Zebra
  ↓
2003: Quagga fork (Zebra abandoned)
  ↓
2009: ExaBGP created (Python automation)
  ↓
2010: BIRD development accelerates
  ↓
2013: GoBGP created (Go implementation)
  ↓
2017: FRRouting fork (Quagga successor)
  ↓
2018: RustyBGP experimental (Rust)
  ↓
2025: Mature ecosystem with choices for every use case

Key Characteristics Summary

BIRD:

  • IXPs and route servers
  • Powerful policy language

FRRouting:

  • Full routing daemon
  • Multi-protocol support

ExaBGP:

  • Automation and programmability
  • Pioneered open source FlowSpec (first implementation, now also in GoBGP/FRR/BIRD)
  • Simple automation API (STDIN/STDOUT, any language)
  • Proven at hyperscale (Facebook/Meta Katran)
  • Pure BGP protocol focus (no RIB/FIB)

GoBGP:

  • Cloud-native design
  • gRPC API

OpenBGPD:

  • Security focus
  • Simple configuration

RustyBGP:

  • Rust memory safety
  • Experimental status

See Also

ExaBGP Documentation:

External Resources:

Performance References:

Still looking?

Let me know if I missed something. This list is reviewed periodically. In 2012, we found another Python program from 2005 called "announcer", so there is surely still more out there.

http://www.dia.uniroma3.it/~compunet/bgp-probing/

👻 Ghost written by Claude (Anthropic AI)

Home

Getting Started

Configuration

API

Address Families

Features

Use Cases

Tools

Operations

Reference

Integration

Migration

Community

External

Clone this wiki locally