Nancy-Playground: A Console Calculator for Deterministic Network Calculus

Deterministic Network Calculus (DNC) is a mathematical framework for analysis of worst-case performance bounds in networked systems. Originating in the 1990s, DNC has evolved into a mature tool for guaranteeing performance in complex systems, with applications extending beyond the original Internet QoS context. Today, DNC is applied in diverse domains, e.g., Time-Sensitive Networks (TSN) for industrial automation and automotive systems [36, 22, 37], avionics for AFDX network certification [7], heterogeneous system-on-chip architectures [29, 4, 5].

While DNC computations can be performed manually for simple examples, in most practical cases they require software support for efficiency and correctness. The research community has developed several software tools, which offer a choice between two extremes. On one side, libraries such as Nancy [43] and Nancy.Expressions [34] provide a rich API for DNC computations in C#. These libraries are powerful and flexible, include many recent algorithmic results [46, 40, 41], and provide a solid base for transparent integration of future results (e.g., [30]) whose research is aided by the open-source nature. However, using them requires some C# programming knowledge and non-trivial “boilerplate” code. On the other side, RTaW’s min-plus playground (MPPG) [27] offers a simpler, calculator-like interface with its own scripting syntax. It is a free-to-use web-hosted counterpart to their commercial offering. This MPPG syntax is minimal and intuitive, and has been used in published research (e.g., [19, 18, 32, 23, 33]). However, RTaW’s playground has significant limitations that hinder its use for research and industrial applications. First, it is proprietary software, with a web-only interface that cannot be used offline, whose license prohibits use for benchmarking and sharing performance results, and which discloses the executed code to the provider. Thus, its use for algorithmic research is severely restricted as one cannot verify, compare or improve the code run by [27]. Second, the MPPG syntax is limited in expressiveness (no functions, branching, loops), which prevents one from generalizing a script to study a network of $n$ nodes and $m$ flows rather than a fixed amount of each. Thus, extending a prototype into a network analysis tool requires a full rewrite in a general-purpose programming language. This friction conflicts with common research and industrial needs: quickly reproducing published results, experimenting with new algorithmic ideas and sharing their performance, quickly extending prototype analyses into full programs.

We address this gap with nancy-playground, a cross-platform command-line interface (CLI) tool that offers a simple, scripting-oriented syntax for DNC computations while addressing the limitations of existing tools. The tool is open source and runs locally, improving transparency, enabling offline work, and supporting code ownership and verifiability. It can run scripts from file or from an interactive command line, supporting the same MPPG syntax as RTaW’s min-plus playground, while performing the actual computations through the Nancy and Nancy.Expressions libraries, thus integrating the latest algorithmic results. Furthermore, nancy-playground is capable of converting MPPG scripts into C# programs that use the Nancy library, thus easing the transition from quick prototyping to full-fledged network analysis tools.

In this paper, we describe the design and implementation of nancy-playground, a tool that bridges the gap between simple script-based exploration and full-program DNC libraries. We present the MPPG syntax, explain the architecture that decouples parsing from computation, and demonstrate how the tool supports interactive exploration, plotting, and translation to C# for production use. nancy-playground is released as open-source software with MIT license [42], and distributed as binary packages for ease of installation [6]. The repository contains many example scripts demonstrating DNC computations across various use cases, providing a reference for researchers and practitioners in the DNC community.

Deterministic Network Calculus (DNC) is a mathematical framework for analysis of worst-case performance bounds in networked systems, which dates back to the early 1990s, and it is mainly due to the work of Cruz [16, 17], Le Boudec and Thiran [21], and Chang [15]. It characterizes constraints on traffic arrivals (due to traffic shaping) and on minimum received service (due to scheduling) as curves, i.e., functions of time, and uses (min,+) and (max,+) algebra to combine the above in order to compute bounds on the traffic at any point in a network traversal.

However, algebraic expressions which look simple on paper can in fact require lengthy computations. The research community has therefore developed several software packages to automate this task, finding efficient data structures to represent functions and curves, and efficient algorithms to implement basic operations. Works [13, 11] provided an “algorithmic toolbox” for DNC: they showed that piecewise affine functions that are ultimately pseudo-periodic (UPP) represent suitable models for both traffic functions and curves, and provided algorithms for most (min,+) and (max,+) algebra operations. The toolbox was first implemented in the COINC free library [12], which is not available anymore, and later by the commercial library RTaW-Pegase [28] and the open-source library Nancy [43, 45, 44].

After its first release, the Nancy library has been extended with more operators and several algorithmic optimizations [46, 39, 40, 41], and a complementary library, Nancy.Expressions [34], has been developed to support lazy evaluation of expressions. Lazy evaluation is a computation strategy where operations are not immediately executed; instead, expressions are represented symbolically, and computations are deferred until the result is actually needed. This approach enables further optimizations that can reduce computation time and memory usage by skipping unnecessary computations. For example, one can employ algebraic simplifications, such as $f\otimes f=f$ if $f(0)=0$ and $f$ is subadditive [21, Sec. 3.1.7], shown in action in [34]; or different strategies of computations that can reduce runtime, like reordering commutative operations [30]. Furthermore, the lazy computation approach will naturally skip computing expressions which are never evaluated, e.g. when the code introduces variables whose value is never used. The Nancy and Nancy.Expressions libraries are suited to large, structured programs that parse complex network configurations and provide a rich API for modeling. To address the need for interactive prototyping, they also support Polyglot Notebooks [3], however, users still need to write C# and manage the surrounding program structure, which can be a barrier for quick experimentation and reproducibility. Moreover, Microsoft recently announced its sudden deprecation, casting doubts on its reliability while open-source forks are being developed.

The RTaW min-plus playground (MPPG) [27] is a web-hosted tool that provides a calculator-like interface for DNC computations using a simple scripting syntax. It supports the same UPP function models and (min,+) operations described above, likely by using the RTaW-Pegase library [28] to implement its computations. It has been used in scientific research (e.g., [32, 23, 33]), in some cases with published code for reproducibility (e.g., [19, 18]). Its simplicity makes it also well-suited for writing accessible tutorials and for postgraduate teaching, as the content can focus on the DNC results rather than programming nuances. However, the RTaW min-plus playground has significant limitations that restrict its utility for research and industrial applications.

First, it is a proprietary web-hosted service that cannot be used offline, and its license explicitly prohibits use for benchmarking and sharing performance results. This creates a fundamental barrier for algorithmic research, where the ability to reproduce results, verify computations, and transparently report performance metrics is essential. Recent advancements such as [46, 41] would not be possible to investigate on RTaW’s playground, even though it is based on the same core toolbox from [13], as researchers using RTaW’s playground cannot share their computation traces or performance evaluations in a verifiable manner, which undermines reproducibility and limits the contribution to the scientific community.

Second, the tool’s code ownership and proprietary nature raise concerns for industrial use in safety-critical and certification contexts. While the web-hosted tool does not satisfy these requirements, we assume the commercial offerings from RTaW may address this point.

Third, the MPPG syntax lacks support for programming constructs such as loops, conditionals, and function definitions, limiting its expressiveness. While this simplicity can be an advantage for interactive exploration, it prevents generalizing scripts to handle parameterized problems (e.g., computing bounds for networks of arbitrary size), forcing researchers to rewrite scripts manually or resort to other tools for structured analyzes. This friction between quick prototyping and full-program development means that users face a costly transition when scaling from simple explorations to production tools.

Other tools and applications for DNC exist, which do not cover the same use cases and needs of the above, and are surveyed in [38]. The most common limitation among these tools is that only a subset of (min,+) and (max,+) functions and operators are supported, limited to the specific use cases supported by that tool. In constrast, Nancy and RTaW-Pegase implement a wide range of operators and function models, leveraging the algorithmic toolbox from [13], making them suitable for general-purpose DNC computations.

RTC Toolbox [35] is a Matlab/Java library that implements variability characterization curves, a model similar to the one from [13], but that assumes operands to be left- or right-continuous based on the operation being performed, and constrains all period lengths to have integer values. It uses floating-point arithmetic and has limited operation support, e.g. it does not support subadditive closure, while Nancy and RTaW-Pegase do. Generally, all computations that can implemented in RTC Toolbox can be implemented in Nancy and RTaW-Pegase, but not the opposite.

Tools like NCorg DNC (originally named DiscoDNC) [9] and CyNC [31] provide an interface focused on network modelling, automating a variety of DNC network analyses and internally using RTC Toolbox for their computations. These may be more suitable for users whose use case is already well supported, but require significant effort to extend to new use cases. [38] also mentions commercial tools that may cover more use cases, including domain-specific models and comparison with simulation.

Some approaches instead rely on DNC to express linear programming problems, rather than (min,+) algebra expressions. Examples of this can be found in tools such as DEBORAH [8] and PANCO [10]. The MPPG syntax is not designed to express such linear programming problems, thus these tools are not directly comparable to nancy-playground.

A few works addressed the formal verification of results, rather than their computations, namely NCCoq and MINERVE [2], which were applied to RTaW-Pegase [26, 14].

The main advantage of the RTaW min-plus playground is its simple syntax, which allows users to express DNC computations concisely, without the overhead of a full programming language. The goal of nancy-playground is to reuse this syntax, to provide a familiar interface to users of the RTaW playground, while enabling local execution and reproducibility, as well as an easier transition to the full capabilities of the Nancy library for network analysis programming.

Using the example from [19], we show in Listing 1 a comparison between the MPPG syntax and the equivalent C# code using the Nancy library. As the example shows, the MPPG syntax is more concise and easier to read, making it ideal for rapid prototyping and experimentation.

MPPG is a concise algebraic language for manipulating min-plus and max-plus curves. It supports scalar values (rationals and $\pm \mathrm{\infty }$) and function values (curves). Its core functionality centers around defining curves, performing operations on them, and either printing values to the console (e.g., a horizontal deviation) or plotting the computed curves. The main statement types are summarized in Table 1: note that there are no equivalents to common programming constructs such as if-then-else or while loops – MPPG can only be used for simple, linear scripts.

Functions can be built from standard constructors (e.g., ratency, bucket, affine) or as piecewise definitions using ultimately affine (uaf) and ultimately pseudo-periodic (upp) forms. Tables 2, 3, 4, and 5 summarize the core syntax used to define curves and run computations on them. These tables do not show all the available constructs, but cover the core syntax needed to express DNC computations.

For more details, the nancy-playground documentation provides a complete reference for all MPPG constructs, both inside the tool through the !help command and in its repository [42, syntax.md]. This documentation is based on the official documentation of RTaW’s min-plus playground [27], which is however not complete, plus our own insights from experimentation with the tool. As a notable example, the assert statements are not mentioned at all in the documentation of [27].

The design of MPPG prioritizes simplicity and readability, eliminating the boilerplate code overhead required by general-purpose languages. Furthermore, the availability of this simple syntax through nancy-playground lowers the barriers to entry for researchers new to DNC, supporting its adoption in teaching and research communities.

nancy-playground is a cross-platform CLI application, written in C# using .NET 10. It is architected to provide a clear separation of concerns between parsing, execution, and code generation. This modular design enables us to support multiple execution backends (immediate vs. lazy evaluation) and output targets (console output, plots, and C# code) without duplicating logic, while also providing a high degree of maintainability for future extensions of the tool capabilities. The core processing pipeline consists of three stages: parsing the MPPG script into an abstract syntax tree (AST), traversing this AST using the visitor pattern to perform computations or generate output, and integrating with the Nancy and Nancy.Expressions libraries to execute DNC operations.

nancy-playground is distributed as open-source software under the permissive MIT license [42]. nancy-playground can run on any system supported by the .NET runtime (8 or above), and we tested it on Linux (Ubuntu 24.04, Fedora 43), Windows 11, Windows 11 on ARM. A compiled version is published on nuget.org [6], which is the standard package manager for .NET applications, using GitHub’s CI/CD features to automatically build and publish new versions. To install nancy-playground from nuget.org, users need to install the .NET SDK and then run the command:

This will download and install nancy-playground to be globally available in the user’s shell. There are three main commands available: run to execute MPPG scripts, interactive to start an interactive prompt, and convert to translate MPPG scripts into C# programs. In the interactive mode, users can also use the !help command to access the integrated manual.

The nancy-playground repository [42] contains example scripts that demonstrate DNC computations, both to show existing techniques in practice and as contexts in which algorithmic results improve computations significantly. These examples are also used within the testing suite mentioned in Section 4.5. We provide here a few of those that can be shown succinctly, with reference to literature for complete explanations. Examples like this can provide reference implementations for users new to DNC, serve as teaching materials for postgraduate courses, and they enable reproducibility of published results. While we cannot directly compare performance with [27], the availability of these open-source examples allows researchers to verify that complex analyses complete in reasonable time and to experiment with variations of the problem.

Listing 3 shows the foundational results from DNC, which are worst-case delay and backlog bounds for a single traffic flow traversing a single node. Listing 4 shows how to address the case with multiple nodes traversed by a single flow: on one hand, we could compute per-node WCDs and sum them, but on the other hand the Pay-Burst-Only-Once result shows that concatenation of service curves yields better bounds.

Listing 5 shows instead how to address a single node contended between multiple flows. To be precise, this is the blind multiplexing case, i.e., where we do not specify the multiplexing policy that the server applies. Note the assumption of strict service curve: recently, [20] provided a new technique that remove this restriction, but requires a new $z$-deviation operator that is currently not supported by MPPG. As discussed in Section 4.1, the architecture of nancy-playground is designed to facilitate the future addition of operators as this one.

The approach illustrated in Listing 4 requires computing the concatenation of service curves via (min,+) convolution. In practice, this operation may be costly, and algorithmic optimizations are needed to make many studies feasible to analyze, as addressed in [46, 40, 41]. Listings 6 and 7 show examples of convolutions where nancy-playground performs the computation with ease, thanks to the results above being implemented in Nancy.

This paper has presented nancy-playground, a tool that addresses a significant gap in the DNC software landscape, the one between full-program DNC libraries and lightweight script-based exploration. nancy-playground provides an open-source, cross-platform and locally-runnable alternative to proprietary web-hosted solution by RTaW.

The tool’s key contributions are threefold. First, it reuses the familiar MPPG syntax from RTaW’s min-plus playground [27], reducing the learning curve for users already familiar with that tool while providing a more accessible entry point for new users compared to C# libraries. Second, by leveraging the Nancy and Nancy.Expressions libraries, nancy-playground executes computations using state-of-the-art algorithms and implementations, integrating recent algorithmic results that may not be available in other tools. Third, it provides a clear transition path from simple script-based prototyping to full-fledged network analysis tools through automatic conversion of MPPG scripts to C# code.

The architecture of nancy-playground demonstrates how formal language design (via ANTLR) can be effectively decoupled from computation, enabling flexible execution strategies (immediate vs. lazy evaluation) and multiple output targets (console, plots, C# code) without code duplication. The modular design also facilitates future extensions, such as support for emerging DNC operators or integration with new algorithmic results.

Beyond the technical contributions, nancy-playground addresses critical non-technical concerns for the DNC community. Being open source software that runs locally on the user’s machine, it enables full reproducibility of research results and supports exploration of new algorithmic techniques. It can also be expanded to address new needs and syntax constructs, such as more powerful asserts, new DNC operators, or plotting features.