galileo/GPS/GLONASS/BeiDou open source monitoring tools.

Highlights:
* Support for Septentrio and U-blox.
* Processes raw frames/strings/words from GPS, GLONASS, BeiDou and Galileo
* All-band support (E1, E5a, E5b, B1I, B2I, Glonass L1, Glonass L2, GPS L1C/A) so far.
* Calculate ephemeris positions
* Comparison of ephemerides to independent SP3 data to determine SISE
+ Globally, locally, worst user location
* Record discontinuities between subsequent ephemerides (in time and space)
* Compare doppler shift as reported by receiver with that expected from ephemeris
* Track atomic clock & report jumps
* Coverage maps (number of satellites >5, >10, >20 elevation)
* HDOP/VDOP/PDOP maps
* Compare orbit to TLE, match up to best matching satellite
* Tear out every bit that tells us how well an SV is doing
* Full almanac processing to see what should be transmitting
* Distributed receivers, combined into a single source of all messages
* Ready to detect/report spoofing/jamming

A utility for querying, configuring, and using a U-Blox GPS.

Inno Setup is a tool to create installers for Microsoft Windows applications.
Inno Extracts allows to extract such installers under non-windows systems
without running the actual installer using wine. Inno Extract currently
supports installers created by Inno Setup 1.2.10 to 5.4.3.

Aladdin Software's StuffIt and StuffIt Expander.

Note:
StuffIt requires registration within 30 days but StuffIt Expander
is freeware.
The registration program is named '%{_bindir}/register-StuffIt'.

bandwidth is an artificial benchmark primarily for measuring memory bandwidth
on x86 and x86_64 based computers, useful for identifying weaknesses in a
computer's memory subsystem, in the bus architecture, in the cache architecture
and in the processor itself.

Pagein is a tool that forces pages that are in swap to be paged in back
to memory. The main usecase for pagein is to exercise the VM and swap
subsystems for testing purposes.

stress-ng can stress various subsystems of a computer. It can stress load CPU,
cache, disk, memory, socket and pipe I/O, scheduling and much more. stress-ng
is a re-write of the original stress tool by Amos Waterland but has many
additional features such as specifying the number of bogo operations to run,
execution metrics, a stress verification on memory and compute operations and
considerably more stress mechanisms.

Typometer is a tool to measure and analyze visual latency of text and
code editors.

Editor latency is delay between an input event and a corresponding
screen update, in particular case – delay between keystroke and
character appearance. While there are many kinds of delays (caret
movement, line editing, etc.), typing latency is a major predictor of
editor usability.

This package parses the config files written in JSON. It also does some
non-JSON stuff, like allowing for comments in the files.

If you want to see it in action, it is used as the config file system in
WebGUI the http://www.webgui.org/ manpage.

This module collects domain validation routines to make input validation,
and untainting easier and more readable.
All functions return an untainted value if the test passes, and undef if
it fails. This means that you should always check for a defined status
explicitly. Don't assume the return will be true. (e.g. is_username('0'))
The value to test is always the first (and often only) argument.

Compare elements of two or more lists

Monitoring::Plugin and its associated Monitoring::Plugin::* modules are a
family of perl modules to streamline writing Monitoring plugins. The main
end user modules are Monitoring::Plugin, providing an object-oriented
interface to the entire Monitoring::Plugin::* collection, and
Monitoring::Plugin::Functions, providing a simpler functional interface to
a useful subset of the available functionality.

The purpose of the collection is to make it as simple as possible for
developers to create plugins that conform the Monitoring Plugin guidelines
(https://www.monitoring-plugins.org/doc/guidelines.html).

This module provides an object type which efficiently represents an
array of booleans. Bitarrays are sequence types and behave very
much like usual lists. Eight bits are represented by one byte in a
contiguous block of memory. The user can select between two
representations; little-endian and big-endian.
All of the functionality is implemented in C. Methods for accessing
the machine representation are provided. This can be useful when
bit level access to binary files is required, such as portable
bitmap image files (.pbm).
Also, when dealing with compressed data which uses variable bit
length encoding, you may find this module useful.

Convert C struct definitions into Python classes with methods for
serializing/deserializing. The usage is very simple: create a class
subclassing cstruct.CStruct and add a C struct definition as a
string in the struct field. The C struct definition is parsed at
runtime and the struct format string is generated. The class offers
the method "unpack" for deserializing a string of bytes into a
Python object and the method "pack" for serializing the values into
a string.

Glances is a cross-platform monitoring tool which aims to present a large amount of monitoring information through a curses or Web based interface. The information dynamically adapts depending on the size of the user interface.

Python wrapper around GNS3 Server API. Its main objective is to
interact with the GNS3 server in a programatic way, so it can
be integrated with the likes of Ansible, docker and scripts.
https://gns3-server.readthedocs.io/en/latest/

A high-level Python API for accessing the Hetzner robot.