Skip to content

BGP Ecosystem

Jump to bottom
Thomas Mangin edited this page Nov 13, 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 Choose Why
IXP Route Server BIRD Fastest performance, powerful policy language, industry standard
Full Routing Daemon FRRouting Modern, actively developed, complete protocol suite
DDoS Mitigation ExaBGP Pioneered open source FlowSpec, proven at scale
Anycast Services ExaBGP Simple API, health check integration, Facebook-scale proven
Kubernetes/Cloud GoBGP or ExaBGP Cloud-native design with gRPC or simple STDIN/STDOUT API
Maximum Performance BIRD Fastest implementation, lowest memory usage
Security First OpenBGPD OpenBSD security focus, auditable codebase
Network Automation ExaBGP Scriptable, any language, flexible
BGP Monitoring pmacct/pmbmpd Production-grade BMP collector
Java Environment freeRouter Full-featured router in Java

Production-Ready Implementations

BIRD - Speed King for IXPs

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

Description: Offers unparalleled efficiency and a powerful filtering language for high-performance, 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
  • Extremely fast performance
  • FlowSpec support (modern versions)

Performance Highlights:

  • Fastest BGP implementation in benchmarks
  • ~25% faster than FRR
  • Lowest memory usage (1M IPv4 routes in 128MB)
  • ~30ns lookup time with 1M routes

Use Cases:

  • IXP route servers (most popular choice)
  • High-performance routing
  • Large routing tables
  • Policy-heavy environments

Strengths:

  • ✅ Fastest performance
  • ✅ Lowest memory usage
  • ✅ Powerful policy language
  • ✅ Industry standard for IXPs

Weaknesses:

  • ❌ Steeper learning curve
  • ❌ Configuration syntax differs from Cisco

Recommendation: Best choice for IXPs, route servers, and performance-critical environments.

FRRouting - Modern Full Stack

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

Description: The undisputed modern champion and spiritual successor to the legacy Quagga project, now the standard recommendation for a full-featured open-source routing solution.

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

Performance Highlights:

  • Single process/core architecture
  • Competitive with BIRD (~25% slower in some tests)
  • Lower memory usage than GoBGP
  • Faster than OpenBGPD

Use Cases:

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

Strengths:

  • ✅ Full-featured routing daemon
  • ✅ Active development and community
  • ✅ Excellent documentation
  • ✅ Wide protocol support
  • ✅ Industry adoption

Weaknesses:

  • ❌ C codebase (harder to contribute than Go/Rust)
  • ❌ Slightly slower than BIRD

Recommendation: Default choice for full routing daemon deployments.

ExaBGP - Automation Specialist

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

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:

  • Slower than compiled implementations (Python)
  • Not designed for full routing table
  • Efficient for route injection/collection
  • Lightweight resource usage
  • 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

Strengths:

  • ✅ Pioneered open source FlowSpec (first implementation)
  • ✅ Simple API accessible from any language
  • ✅ Easy deployment (Python only dependency)
  • ✅ Flexible and scriptable
  • ✅ Proven at Facebook/Meta scale (Katran)
  • ✅ Active development and community

Weaknesses:

  • ❌ Slower than C/Go/Rust implementations
  • ❌ Not a full routing daemon
  • ❌ No RIB/FIB manipulation

When to Choose ExaBGP:

  • Automation and orchestration
  • FlowSpec DDoS mitigation
  • Anycast health checks
  • BGP as an API
  • Integration with existing infrastructure

Recommendation: Best choice for automation, FlowSpec, anycast, and programmable BGP.

For complete ExaBGP documentation, see:

GoBGP - Cloud Native

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

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:

  • Slower than BIRD/FRR in benchmarks
  • Multi-core support
  • Higher memory usage (~2x more than BIRD/FRR)
  • Higher CPU usage
  • Performance acceptable for most cloud use cases

Use Cases:

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

Strengths:

  • ✅ Modern language (Go)
  • ✅ gRPC API
  • ✅ Easy to contribute
  • ✅ Cloud-native design
  • ✅ Multi-core support
  • ✅ Active development

Weaknesses:

  • ❌ Slower than BIRD/FRR
  • ❌ Higher memory usage
  • ❌ Higher CPU usage

Recommendation: Good choice for cloud/Kubernetes deployments, but consider performance requirements.

OpenBGPD - Security First

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

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:

  • Slower with >10 neighbors (2-3x slower than BIRD)
  • Higher memory usage
  • Single process architecture
  • Focus on correctness over speed

Use Cases:

  • Security-conscious deployments
  • OpenBSD systems
  • Simple BGP setups
  • Small to medium deployments

Strengths:

  • ✅ Security-focused
  • ✅ Simple configuration
  • ✅ OpenBSD quality and code review
  • ✅ Clean, auditable codebase

Weaknesses:

  • ❌ Slower performance (2-3x slower than BIRD)
  • ❌ Higher memory usage
  • ❌ Limited features vs. FRR/BIRD

Recommendation: Good choice for security-focused or small deployments where OpenBSD quality matters.

Emerging Implementations

RustyBGP - Rust Safety

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

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 (2021-2022 benchmarks):

  • Slower than BIRD/FRR in current state
  • Uses all CPU cores efficiently
  • Lowest memory usage in high-neighbor tests
  • May have improved significantly since benchmarks

Strengths:

  • ✅ Rust memory safety
  • ✅ Multi-core utilization
  • ✅ Low memory usage
  • ✅ GoBGP API compatible

Weaknesses:

  • ❌ Not yet fully formed BGP stack
  • ❌ Limited policy support
  • ❌ Experimental status

Recommendation: Promising but not production-ready. Monitor for future development.

bio-routing - Multi-Protocol

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

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

If you are a Go person, this is for you! The developers really put thought into the implementation.

Strengths:

  • ✅ Modern Go codebase
  • ✅ Multi-protocol support
  • ✅ Well-architected

Weaknesses:

  • ❌ Less mature than FRR/BIRD
  • ❌ Limited production adoption

Recommendation: Interesting project, but consider maturity needs.

CoreBGP - Go Library

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

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

Strengths:

  • ✅ Pluggable architecture
  • ✅ Full control for developers
  • ✅ Modern Go library

Weaknesses:

  • ❌ Not a ready-to-use daemon
  • ❌ Requires custom implementation

Recommendation: For developers building custom BGP applications.

Language-Specific Options

If You Are a Go Person

Then these are for you! (We really like bio-routing implementation)

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

    • Production-ready 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

Use one of these production-grade implementations:

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

    • Fastest performance
    • Best for IXPs and route servers
    • Powerful policy language

  2. FRRouting - https://frrouting.org

    • Full routing protocol suite
    • Modern development
    • Best for enterprise/ISP

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

    • Security-focused
    • OpenBSD quality
    • Simple configuration

If You Are a Rust Person

The Rust ecosystem is emerging:

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

    • Most complete implementation
    • Multi-core support
    • Experimental but promising

  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 Rating: ⭐⭐⭐⭐⭐

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 Rating: ⭐⭐⭐

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

Recommendation: Good for analysis and testing, but consider ExaBGP for production.

BaGPipe-BGP - OpenStack Integration

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

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

Recommendation: For OpenStack deployments.

Ryu - SDN Framework

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

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

Recommendation: For SDN use cases.

PyBal - Wikimedia Load Balancer

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

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

Recommendation: Niche use case specific to Wikimedia patterns.

pybgp - Twisted Framework

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

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

Recommendation: Consider ExaBGP or YABGP instead.

Specialized Tools

pmacct / pmbmpd - BMP Monitoring

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

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

Recommendation: Essential tool for BGP monitoring.

pbgp-parser - PCAP Analysis

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

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 Rating: ⭐⭐

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 Comparison

⚠️ Important: These benchmarks are from 2021-2022 and may not reflect current performance. Software changes significantly over 3-4 years. Use as historical reference only.

Speed Ranking (Fastest to Slowest)

  1. BIRD - ⚡⚡⚡⚡⚡ Fastest
  2. FRRouting - ⚡⚡⚡⚡ Very fast (25% slower than BIRD)
  3. RustyBGP - ⚡⚡⚡ Moderate (improving)
  4. OpenBGPD - ⚡⚡ Slow (2-3x slower than BIRD with >10 neighbors)
  5. GoBGP - ⚡ Very slow (24s vs 3-4s in older benchmarks)
  6. ExaBGP - ⚡ Python overhead (not designed for full table)

Memory Usage Ranking (Lowest to Highest)

  1. RustyBGP - Lowest (high neighbor count)
  2. BIRD - Very low (1M routes in 128MB)
  3. FRRouting - Low
  4. GoBGP - ~2x more than BIRD/FRR
  5. OpenBGPD - Highest in tests

Multi-Core Support

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

Performance Summary Table

Implementation Language Speed Memory Cores Rating
BIRD C ⚡⚡⚡⚡⚡ Low Single ⭐⭐⭐⭐⭐
FRRouting C ⚡⚡⚡⚡ Low Single ⭐⭐⭐⭐⭐
ExaBGP Python ⚡⚡ Low Single ⭐⭐⭐⭐⭐
GoBGP Go ⚡ High Multi ⭐⭐⭐⭐
OpenBGPD C ⚡⚡ High Single ⭐⭐⭐⭐
RustyBGP Rust ⚡⚡⚡ Lowest Multi ⭐⭐⭐

Decision Matrix

By Use Case

IXP Route Servers

Winner: BIRD ⭐⭐⭐⭐⭐

  • Fastest performance
  • Powerful policy language
  • Industry standard
  • Lowest memory usage

Full Routing Daemon (Enterprise/ISP)

Winner: FRRouting ⭐⭐⭐⭐⭐

  • Modern, actively developed
  • Full protocol suite
  • Good performance
  • Wide adoption
  • Excellent documentation

DDoS Mitigation / FlowSpec

Winner: ExaBGP ⭐⭐⭐⭐⭐

  • Pioneered open source FlowSpec (now also in GoBGP, FRR, BIRD)
  • Simple API for automation
  • Proven at Facebook/Meta scale
  • Easy integration with mitigation systems

Note: Modern versions of BIRD, FRR, and GoBGP also support FlowSpec, but ExaBGP's API makes automation easier.

Network Automation / Anycast

Winner: ExaBGP ⭐⭐⭐⭐⭐

  • STDIN/STDOUT API
  • Any language integration
  • Python flexibility
  • Health check integration
  • Facebook Katran uses it

Cloud-Native / Kubernetes

Winners:

  1. GoBGP ⭐⭐⭐⭐ - gRPC API, modern design
  2. ExaBGP ⭐⭐⭐⭐ - Simple integration, container-friendly
  3. bio-routing ⭐⭐⭐ - Go-native

Security-Focused Deployments

Winner: OpenBGPD ⭐⭐⭐⭐

  • OpenBSD security focus
  • Simple, auditable code
  • Clear configuration
  • Proven security track record

High-Performance Environments

Winner: BIRD ⭐⭐⭐⭐⭐

  • Fastest BGP implementation
  • Lowest memory usage
  • Handles full routing tables efficiently
  • Industry proven

Research / Experimentation

Winners:

  1. freeRouter ⭐⭐⭐⭐ - Full features, P4 support
  2. RustyBGP ⭐⭐⭐ - Modern Rust
  3. YABGP ⭐⭐⭐ - Analysis focus

By Language Preference

Language Production 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

Choose ExaBGP when:

  • You need automation and programmability
  • FlowSpec DDoS mitigation is your focus
  • Anycast with health checks
  • BGP as an API for applications
  • Integration with existing infrastructure
  • Python ecosystem preference

Choose BIRD/FRR when:

  • You need a full routing daemon
  • RIB/FIB manipulation required
  • Traditional router replacement
  • Multi-protocol support (OSPF, ISIS, etc.)
  • Maximum performance with full routing tables

Key Difference:

  • ExaBGP: Pure BGP protocol, no RIB/FIB, API-driven, automation focus
  • BIRD/FRR: Full routing stack, kernel integration, traditional daemon

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 Takeaways

  1. No single "best" implementation - depends on use case
  2. BIRD = Performance king for IXPs and route servers
  3. FRRouting = Default choice for full routing daemon
  4. ExaBGP = Automation specialist for FlowSpec/anycast/programmability
  5. GoBGP = Cloud-native but slower
  6. OpenBGPD = Security focus but slower
  7. Rust/Go = Future but not yet fully mature

ExaBGP's Unique Value:

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

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