[opensourcedex]

Kathara is a free, open source networking & connectivity project written in Python and released under GPL-3.0. It has 645 GitHub stars, 86 forks and 16 open issues, and was last pushed 24 hours ago. On this registry it ranks #54 of 55 tracked projects in Networking & Connectivity, with 5 head-to-head comparisons available.

What is Kathara?

Kathará is a lightweight, container-based network emulation system for network engineers, students, and researchers who need to build, test, and demonstrate virtual networks on Docker or Kubernetes.

What it is

Kathará (from the Greek Καθαρά, "purely") is a network emulation framework written in Python in which every emulated network device runs as a Docker container. Containers are interconnected by virtual L2 LANs, and each device may run a different Docker image, with built-in images including Quagga, FRRouting, Bind, P4, and OpenVSwitch alongside any custom image you supply. The system organises work into a network scenario: a directory containing a file describing the topology plus, for each device, the files and folders holding that device's configuration. Scenarios can be emulated with either Docker or Kubernetes as the backend virtualization system.

The concrete problem it addresses is the cost and complexity of assembling a realistic multi-device network — routing daemons, DNS, programmable dataplanes — for teaching, sandboxing, or protocol development. By deriving each device from a container and each scenario from plain files such as lab.conf and *.startup files, Kathará turns what would otherwise require hardware or heavyweight virtual machines into a directory you can start, interact with, and tear down from the command line.

Key capabilities

  • Launch a whole scenario with kathara lstart, which reads configuration from lab.conf and the various *.startup files and opens terminal windows for interacting with each device.
  • Tear down a running scenario with kathara lclean.
  • Emulate routing protocols through built-in images for Quagga, FRRouting, and RIP/OSPF/BGP deployments, plus a DNS server via Bind.
  • Run programmable dataplane experiments using the P4 language and OpenVSwitch images.
  • Choose Docker or Kubernetes as the virtualization backend, including the Megalos architecture for Kubernetes.
  • Provide Python APIs for driving scenarios programmatically, documented through a dedicated Python APIs tutorial and API docs.
  • Reuse Netkit scenarios directly, since Kathará is the spiritual successor of Netkit and is cross-compatible with its language and features.

Who uses it and how

  • Instructors run interactive demos and lessons, launching a prepared scenario so students get terminals into live devices immediately.
  • Network engineers test production network configurations in a sandbox environment before deployment.
  • Researchers develop new network protocols and evaluate routing protocol implementations, as in the Sibyl framework for fat-tree evaluations.
  • Teams working on network function virtualization and software defined networks build scenarios with the Python APIs rather than the CLI.
  • Users with large scenarios distribute emulation across a Kubernetes cluster through Megalos (Kathara over Kubernetes).

Getting started

Install Docker, then run the installer specific to your operating system as described in the project Wiki, and start the provided "Small Internet" example scenario with kathara lstart from inside its directory.

How it compares

Kathará explicitly positions itself as the spiritual successor of Netkit and is cross-compatible with it, inheriting Netkit's language and features while re-basing the emulation on Docker containers and offering Kubernetes as an alternative backend. Where Netkit predates container orchestration, Kathará adds container image reuse, Python APIs, and the Megalos architecture for scaling scenarios across a cluster.

When to use it — and when not

A self-hoster must have Docker installed, and, if choosing the Kubernetes route, an operable cluster with the Megalos components configured. It is not the right pick for anyone needing full protocol-faithful hardware emulation or who cannot run containers on the target machine, and the repository currently carries 16 open issues. The project is licensed under GPL-3.0, which obliges derivative distributions to carry the same licence.

project readme (upstream, from github) — read inline

Kathará

License: GPL v3

What is it?

Kathará (from the Greek Καθαρά, purely) is a lightweight network emulation system based on Docker containers. It can be really helpful in showing interactive demos/lessons, testing production networks in a sandbox environment, or developing new network protocols.

Kathará is the spiritual successor of the notorious Netkit, hence it is cross-compatible, and inherits its language and features.

How does it work?

Each network device is emulated by a container. Virtual network devices are interconnected by virtual L2 LANs.

Each container can potentially run a different Docker image. Built-in images include Quagga, FRRouting, Bind, P4, OpenVSwitch, and more, but you can also use your own container images. For more information about Kathará images please visit the dedicated repository.

Kathará extremely simplifies the creation of complex networks using the concept of network scenario: a directory containing a file with the network topology, and, foreach device, files and folders containing the configuration of that device.

Kathará emulates network scenarios using either Docker or Kubernetes as backend virtualization system.

Installation

Install Docker and then run the installer specific for your Operating System. For a step-by-step guide check the Wiki.

For further information on how to use Kathará on Kubernetes (Megalos) please refer to the Wiki Page.

Kathará also provides a set of Python APIs. See the Python APIs Tutorial and the docs.

Quick Example

  • Install Kathará by following the Installation section.
  • Download and unpack the network scenario of a "Small Internet" from here (network topology can be found here).
  • cd inside small-internet-with-dns-webserver and run kathara lstart.
  • Kathará will read the configuration of the scenario from lab.conf and the various *.startup files and start the devices, opening terminal windows to interact with them.
  • After you're done experimenting, simply run kathara lclean and wait until the network scenario closes.

Publications and Presentations

Kathará is developed by Roma Tre Computer Networks and Security Research Group.

Several publications are related to the tool:

Kathará has been also presented in meetings and workshops:

External Tools

  • Netkit Lab Generator, a GUI that allows the easy creation of a network scenario configuration and the visualization of its network topology.
  • VFTGen, a tool that allows creating three levels Fat Tree topologies (single-plane or multi-planes) and automatically configure them to run on Kathará.
  • Tacatá, a lightweight Python script which creates Netkit and Kathará labs using an enriched version of the lab.conf file with a simple syntax.
  • net-vis, a tool that parses (and generates) the lab.conf file and all the .startup files to visualize the network.
  • kathara-lab-starter, an easy and extensible tool to get a kathara lab started. Utilizing JSON input files, it accelerates setup, while minimizing configuration redundancies.
  • NetGUI-Kathará, NetGUI-Kathará is a graphical interface for Kathará that lets users design and manage network topologies. It also generates files for 3D traffic visualization with WireXRk.
  • NIKA: A Network Arena for Benchmarking AI Agents on Network Troubleshooting. It offers an orchestration platform that connects AI agents with the network environment, enabling real-time troubleshooting in realistic conditions, and providing a human-facing interface to monitor agent performance.
  • SysResEval: An open-source software suite for teaching and managing exercise sessions and evaluations in network and system administration courses. Students work through guided exercises in a GUI; instructors monitor sessions and run time-limited exams with automatic, reproducible grading.

Success Stories

As far as we know, Kathará is currently being used in many courses and projects.

We encourage you to tell us your story!

We are also collecting network scenarios from the community. If you want to be added to the list, please contact us!

Join Us

Kathará is an open source project. Feel free to download the code, play with it, and submit feature requests, notify bugs, or open pull requests!

Thanks to everyone who has contributed to the development of Kathará!

Frequently asked questions

Is Kathara free to use?

Kathara is open source under the GPL-3.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Kathara do?

A lightweight container-based network emulation system.

What is Kathara written in?

Kathara is primarily written in Python. Its source is publicly available at https://github.com/KatharaFramework/Kathara, and it has 645 GitHub stars.