This project contains various benchmarks and related tools. While building is enabled for other distributions then Tumbleweed/Factory, primary purpose of this project is development, not backporting for older releases. Do not add this project repositories to your systems unless you know what you are doing and are willing to fix issues you encounter.

Blogbench is a portable filesystem benchmark that tries to reproduce the load
of a real-world busy file server. It stresses the filesystem with multiple
threads performing random reads, writes, and rewrites in order to get a
realistic idea of the scalability and the concurrency a system can handle.

A tool which profiles OpenCL devices to find their peak capacities like
bandwidth & compute.

fio is an I/O tool meant to be used both for benchmark and stress/hardware
verification. It has support for 4 different types of I/O engines (sync,
mmap, libaio, posixaio), I/O priorities (for newer Linux kernels), rate I/O,
forked or threaded jobs, and much more. It can work on block devices as
well as files. fio accepts job descriptions in a simple-to-understand text
format. Several example job files are included. fio displays all sorts of
I/O performance information, such as completion and submission latencies
(avg/mean/deviation), bandwidth stats, cpu and disk utilization, and more.

Meabo is a multi-phased multi-purpose micro-benchmark. It is a highly
configurable tool which can be used for energy efficiency studies, ARM
big.LITTLE Linux scheduler analysis and DVFS studies. It can be used for
other benchmarking as well.

The micro-benchmark is composed of 10 phases that perform various generic
calculations (from memory to compute intensive). None of the compute
kernels are optimized for a specific architecture. The micro-benchmark is
easily extensible, provides performance counter readings (today) and energy
readings (in the future), has multi-core and flexible pinning support, and
allows the user to run each phase in different configurations/

One of the main benefits of this tool is that it is scalable beyond the
aforementioned investigations, and is useful for anyone who would like
to understand system behaviour, whilst running small, simple and
well-understood computational kernels. The level of flexibility built into
the application is an added benefit, as it gives the user full control of
what is being run, where it is run, and whether it's single or
multi-threaded, all within the same run of the application.

The packetdrill scripting tool enables quick, precise tests for entire
TCP/UDP/IPv4/IPv6 network stacks, from the system call layer down to the
NIC hardware. packetdrill currently works on Linux, FreeBSD, OpenBSD, and
NetBSD. It can test network stack behavior over physical NICs on a LAN, or
on a single machine using a tun virtual network device.

An extensible Vulkan benchmarking suite with targeted, configurable scenes.

Mark Hessling's implementation of the REXX language.

The Anthropic Python library provides convenient access to the
Anthropic REST API from any Python 3.9+ application. It includes type
definitions for all request params and response fields, and offers both
synchronous and asynchronous clients powered by httpx.

Asynchronous file IO for Linux (libaio and POSIX AIO), with a thread-pool
based fallback. Provides a small, fast async file-IO layer.

Cheetah3 is a free (BSD-style) and open source template engine and code
generation tool.

It can be used standalone or combined with other tools and frameworks. Web
development is its principle use, but Cheetah is very flexible and is also being
used to generate C++ game code, Java, sql, form emails and even Python code.

It's a fork of the original CheetahTemplate library.

Python SDK for CubeSandbox, a lightweight microVM sandbox service for AI
agents built on RustVMM and KVM. The SDK talks to a CubeSandbox control-plane
API to create and manage hardware-isolated sandboxes, run commands and stream
their output, manage the sandbox filesystem, build and manage templates, and
apply per-sandbox network policies.

FastMCP is the fast, Pythonic way to build Model Context Protocol (MCP)
servers and clients. This is the full distribution, pulling in fastmcp-slim
with the client and server integrations enabled; the importable "fastmcp"
module is provided by fastmcp-slim.

FastMCP is the fast, Pythonic way to build Model Context Protocol (MCP)
servers and clients. This "slim" distribution provides the full client
and server stack with the standard set of optional integrations enabled.

A retry layer for the HTTPX client: configurable retry behaviour with
exponential backoff for transient HTTP errors.

Integration package connecting Claude (Anthropic) APIs and LangChain.

This package contains the LangChain integrations with AWS, connecting
LangChain to AWS services such as Amazon Bedrock, SageMaker, Neptune and
Kendra.