CPANscan

Astro::SpaceTrack is a Perl client for fetching orbital element sets and related satellite data from Space‑Track.org and several public repositories such as Celestrak and Mike McCants' site, letting you retrieve TLEs, catalog/search results, box scores and other satellite lists programmatically or from an interactive shell. It wraps requests in HTTP::Response objects, supports JSON and legacy TLE formats, can read credentials from an identity file or environment variables, and offers convenience features like local caching and an included SpaceTrack command script. Note that a registered Space Track username is required for most Space Track queries and usage should be throttled (daily or at most every few hours is usually sufficient). Version 0.180 was an emergency update to restore operation after Space Track removed the old 'tle' and 'tle_latest' classes; it now uses the newer 'gp' and 'gp_history' classes but also documents a few current limitations such as the deprecated --last5 option, the removal of the OBJECT_NUMBER datum (use NORAD_CAT_ID), and some Space‑Track favorites that were reported 404.

TOON::XS is a fast, XS (C) implementation of the TOON data format for Perl that handles both line-style and brace-style syntaxes and provides both functional and object oriented APIs for encoding, decoding, and validating Perl data structures. It exposes dedicated functions like encode_line_toon/decode_line_toon and encode_brace_toon/decode_brace_toon plus generic encode_toon/decode_toon that require an explicit syntax parameter, and it also offers a TOON::XS->new(...) object with persistent options such as syntax, pretty, canonical and indent along with setter methods for convenient reuse. The module focuses on performance and benchmarks show large speedups over pure-Perl TOON and Data::TOON, particularly for decoding, while only requiring Perl 5.10. Decoders will throw on invalid input and validators return boolean results, and the current release is the initial 0.001 publication.

App::MARC::Filter is a lightweight Perl application class that powers a command line tool for selecting and emitting MARC bibliographic records. You create an instance with new and call run to read MARCXML, USMARC or compressed MARC inputs and filter records by leader, control fields, data fields and subfields or by material type, with options for invert matching, limiting output count and verbose or ASCII output. It is aimed at developers and catalogers who need a simple programmable filter for MARC data rather than a full MARC toolkit. Recent releases added support for compressed input files and improved detection of XML input files.

Time::OlsonTZ::Data packages a specific release of the Olson/IANA timezone database for Perl so you can ship and query authoritative timezone data without relying on the host system files. It exposes the database version, lists of canonical zone names and aliases, a mapping of alias-to-canonical names, a country-to-region map to help users pick a geographic timezone, and a function that returns the pathname of the compiled binary tzfile for any named zone. The module is meant to be updated regularly to follow real-world rule changes, so you should refresh installs from CPAN to stay current, and be aware that long-running programs may see tzfiles change if the module is updated while they run.

FB3::Convert is a small Perl toolkit from Litres.ru that supplies both ready-to-run scripts and a programming API for converting FB3 electronic book files to and from other formats. If you work with FB3 ebooks and need a straightforward way to automate format conversions or to embed conversion logic in a Perl application, this module gives you that capability without forcing you to reimplement parsing or export routines. It is distributed as free software under the GNU Lesser General Public License version 3 and comes with the usual no-warranty terms.

FastGlob provides a pure-Perl implementation of filename globbing that you can export as glob to replace Perl's built-in glob. Because it avoids forking a csh it runs faster and is more robust on systems where a shell-based glob can fail with very large directories. It auto-detects platform conventions and exposes a few module variables you can adjust such as $FastGlob::dirsep, $FastGlob::rootpat, $FastGlob::curdir, $FastGlob::parentdir and $FastGlob::hidedotfiles so you can adapt behavior for Windows, Unix or classic Mac OS. Tilde expansion uses the system password database on Unix and falls back to HOME or USERPROFILE on Windows. If you want a lightweight, configurable, drop-in glob replacement that avoids spawning a shell, FastGlob is a practical choice.

PPI is a Perl library for parsing Perl source as a document rather than executing it, so you can safely read, analyze and transform code without running it. It tokenizes files and builds a Perl Document Object Model that preserves whitespace, comments and POD so modifications can be made and written back exactly as they were, making it ideal for tasks like documentation extraction, static analysis, automated refactoring, code formatting and tools such as Perl::Critic. The module is pure Perl, widely used and available on CPAN and GitHub, and exposes a rich API for querying and manipulating statements, structures and tokens. There are some limits you should know about: PPI does not attempt to fully parse Perl as running code so constructs that rely on runtime or external context, source filters or certain lexical extensions can confuse it, and Unicode support is limited to Latin-1. Performance can be slower on very large files, though an XS accelerator exists as a work-in-progress. If you need to inspect or change Perl source safely without executing it, PPI is a mature and practical choice.

YAML::Syck is a fast, lightweight Perl binding to the libsyck YAML serializer that converts Perl data structures to YAML and back via simple Load and Dump functions and file helpers like LoadFile and DumpFile. It exposes a handful of flags to control behavior, including implicit typing, Unicode and binary handling, key sorting, headless output, maximum nesting depth, and whether to allow evaluation or blessing of code and objects, and it also offers explicit encoding helpers such as LoadBytes, LoadUTF8, DumpBytes and DumpUTF8 for precise byte versus UTF-8 handling. The module aims for speed and good interoperability with other Syck wrappers, but note that some calls may die on error instead of returning YAML so you should guard calls with eval, it implements the older YAML 1.0 spec, it bundles its own libsyck sources, and it has known issues and limited maintenance since 2007, so if you need full YAML 1.1 support or a more actively maintained parser you may prefer YAML::XS.

NBI::Slurm is a Perl toolkit for creating and submitting SLURM jobs from scripts or the command line. It supplies NBI::Job and NBI::Opts classes so you can programmatically build job scripts, set names, commands, output files and resource requests like threads and memory, then submit them to a SLURM scheduler. The distribution also includes practical CLI utilities for launching, listing and inspecting jobs, and for interactive job sessions and management. Recent releases improved the interactive viewer to persist completed jobs and let you inspect StdOut and StdErr files, and refined listing and summary output to make results easier to read. If you manage or automate workloads on SLURM-based HPC clusters and work in Perl, NBI::Slurm provides a convenient, battle-tested interface.

XML::Parser is a Perl interface to the Expat XML library that makes it easy to parse XML from strings, files, sockets, or incremental streams. It offers both event-driven handlers and ready-made parsing "styles" so you can print a debug outline, dispatch element names to subs, build a nested tree or object model, or process documents in a streaming fashion. You register handlers for events like start tag, end tag, text, processing instructions, comments, and external entities and the module delivers text to you in UTF-8. It supports common needs such as namespace handling, custom encodings, and configurable external entity resolution with an LWP-based default, and it exposes modern Expat security controls to limit entity expansion and allocation to mitigate XML bomb attacks. Parse errors are reported by exceptions so you can catch them with eval. This module is a good fit if you write Perl code that needs flexible, efficient XML parsing and you are comfortable relying on the underlying libexpat library and its available features.

Dist::Zilla::Plugin::WeaveFile is a Dist::Zilla plugin that helps you keep repository-facing files like README and INSTALL in sync with your distribution by generating them from templates that combine distribution metadata, POD documentation, and reusable text snippets. You write a YAML config (default .weavefilerc) using Template::Toolkit syntax and the plugin exposes a dist object, snippets, and a pod extractor that converts POD sections to Markdown so your templates can pull live documentation and version info into the generated files. The plugin validates the configuration during build and works with Dist::Zilla::Plugin::Test::WeaveFile to embed the generated output in xt/author tests so any drift shows up as a failing test, and you update files on demand with the dzil weave command. The module is in early release and may still evolve; version 0.001 is the initial publication.

Crypt::OpenSSL::RSA is a Perl interface to the OpenSSL libraries that makes it easy to generate, load and export RSA keys and to perform common RSA operations such as encrypt, decrypt, sign and verify. The module accepts PEM or DER keys, can generate key pairs with a custom exponent, and exports public and private keys in PKCS#1, PKCS#8 and X.509 formats so it fits into typical certificate and key workflows. Padding and hash options are exposed so you can use OAEP for encryption and RSA‑PSS or PKCS#1 v1.5 for signatures, and the module warns that plaintext length depends on key size and padding. Note that some operations will croak on error so you should catch exceptions, and the module integrates with Crypt::OpenSSL::Random for seeding. The recent 0.38 release focused on OpenSSL 3.x compatibility and bug fixes and re-enabled PKCS#1 v1.5 for sign/verify while keeping vulnerable v1.5 decryption disabled, and also added PKCS#8 private key export and various robustness and memory‑leak fixes.

IO::Tty is a low-level Perl module that handles creation and management of pseudo-terminals (ptys) and exports related system constants, but it is intended to be used indirectly via IO::Pty rather than called directly by most programs. It provides the plumbing needed to open master and slave tty devices, set terminal modes and window sizes, and expose constants in IO::Tty::Constant, while supporting a wide range of UNIX-like platforms and Cygwin. Because pty behavior is highly system dependent the module documents platform quirks and runs a broad CI test matrix on Linux, macOS and several BSDs, so it is a good fit if your code needs reliable PTY allocation across systems. The recent 1.28 release focused on portability and robustness fixes, including correct controlling-terminal setup on Solaris and HP-UX, preventing ioctl buffer warnings on newer Perls, closing file descriptor leaks, and improving detection on musl-based systems, so it is well maintained for modern Perl environments. Use IO::Pty for high-level pty handling and reach for IO::Tty only when you need direct constants or to work at the OS-level tty interface.

Crypt::RIPEMD160 is a Perl extension that implements the RIPEMD-160 cryptographic hash so you can compute 160-bit message digests from Perl code. It presents the familiar Digest-style API for incremental use or one-shot hashing, letting you create contexts, add data or files, clone mid-stream state, and get binary, hex, or base64 digests, and it can be loaded via Digest->new('RIPEMD-160') for easy integration with existing code. The module wraps a proven C implementation and includes conveniences such as addfile and hexhash while keeping performance suitable for typical hashing tasks. Recent updates improved compatibility and safety by adopting Digest::base, fixing wide-character handling, ensuring binmode on file reads, returning $self for method chaining, and wiping sensitive key material to reduce leakage risk. The software is free and redistributable under the same terms as Perl.

Test2::Harness is the test-runner engine behind the modern Test2 ecosystem, responsible for executing, orchestrating and collecting results from Perl test suites while exposing hooks for plugins and resource managers. It is intended to be used via the App::Yath command layer which provides the user interface and convenience commands, and it supports parallel and persistent runners, preload/reload modes, coverage and notification plugins, rerun and interactive workflows, and robust handling of non‑Perl tests. The project focuses on resilient scheduling, clear logging and extensibility so you can integrate coverage, timing and custom resource logic into large or long‑running test workflows. Recent maintenance has improved reliability on slow CI hosts by increasing the preload integration watchdog timeout and added tighter integration with the App::Yath script, plus fixes to make the scheduler and resource handling more robust and to add options for failing on skipped resources.

App::Yath::Script is the small bootstrap used by the yath test-harness script to handle script discovery, early initialization, and delegation to versioned harness backends. It runs in the BEGIN phase to set up @INC, seed PERL_HASH_SEED for reproducible hashing, load project and user config files (.yath.rc and .yath.user.rc), determine which App::Yath::Script::V{X} module should handle the rest of startup and runtime, and then hands off control for execution. Version selection is driven by config filenames and symlinks so you can use explicit .yath.v#.rc files or point a stable .yath.rc symlink at a versioned file, plain .yath.rc still defaults to V1, user-level config can override project config, and recent updates added CLI-first-argument version selection and an environment variable (YATH_SCRIPT) for the script. The module also exports handy utilities for script writers such as script(), module(), do_exec(), clean_path(), find_in_updir(), and mod2file() to re-exec the script, normalize and locate files, and translate module names to file paths. If you run, customize, or extend the yath harness this module is the entry point that manages startup policy and versioned delegation.

CPAN::Plugin::Sysdeps is a CPAN.pm plugin (with a standalone cpan-sysdeps helper) that automates installation of non‑Perl system packages needed by CPAN modules by mapping module or distribution names to OS package names and invoking the appropriate system package manager. It detects your OS and distribution and can call apt, aptitude, yum, dnf, pkg, homebrew or choco as needed, supports batch, interactive and dry‑run modes, and lets you extend or override its static mapping with custom mapping files. The module is particularly useful for CPAN testers and for anyone who wants CPAN installs to pull in native libraries and devel packages automatically, and it works best on FreeBSD and Debian‑like Linux while offering fair support for Fedora, macOS and limited Windows support. Recent releases add Alpine Linux support, numerous mapping updates and small fixes such as using choco for Windows and documenting DEBIAN_FRONTEND=noninteractive; note that mappings are maintained as static rules, installation failures can abort with error messages, and some platforms remain better supported than others.

CryptX is a comprehensive Perl cryptography toolkit that exposes a wide set of vetted crypto primitives by wrapping the LibTomCrypt library, making it easy for Perl developers to perform encryption, hashing, signing and secure random generation without dealing with low level C details. It provides symmetric ciphers (AES, Twofish, Serpent and many more), block cipher modes, stream ciphers, authenticated encryption modes (GCM, CCM, ChaCha20‑Poly1305, OCB), a large collection of hash functions (SHA, SHA3, Keccak, BLAKE2), MACs and checksums, public‑key algorithms (RSA, DSA, ECC, Ed25519, X25519, DH), cryptographically secure PRNGs, key derivation functions and miscellaneous helpers for key import/export and encoding. The project is actively maintained and tested across platforms. The most recent release added several new password‑based KDF helpers (pbkdf1_openssl, bcrypt_pbkdf, scrypt_pbkdf, argon2_pbkdf), new UUID helpers in Crypt::Misc, updated the bundled libraries, and addressed a security advisory (CVE‑2026‑41564). Choose CryptX when you need direct, portable access to a broad set of cryptographic tools from Perl code.

Gnuplot::Builder is an object oriented Perl helper for creating and running gnuplot scripts from your programs, letting you treat whole plots and data sets as Script and Dataset objects instead of dealing with gnuplot global state. It is a thin, predictable layer that simply builds script text and pipes it to gnuplot, so it is easy to use in both batch and interactive sessions, supports prototype-style inheritance for hierarchical configuration, and can run multiple gnuplot processes in parallel. The module exports convenient helpers such as gscript, gfile, gdata, gfunc, ghelp and gwait, and Windows users can opt for Gnuplot::Builder::Wgnuplot to improve window behavior. Because the module leaves script validation to gnuplot, you may need to inspect gnuplot output or enable the provided Tap facility when things go wrong, and interactive plot windows sometimes require tuning of persist and pause modes depending on your platform and gnuplot version.

App::MARC::Validator::Report is a small command line utility that turns MARC record validation into clear, shareable reports, helping librarians, archivists, and developers spot and track problems in bibliographic data. Instead of wrestling with raw validator output, you get concise summaries and statistics that make it easier to prioritize fixes, audit batches of records, and communicate issues to colleagues or downstream workflows. If you work with MARC files and need a straightforward way to review validation results, this tool simplifies the process and saves time.

Bitcoin::Crypto is a Perl library that gives developers programmatic, low level access to Bitcoin cryptography and primitives. It provides tools to generate mnemonics and extended keys, derive hierarchical keys (including modern Taproot paths), work with private and public keys, build and inspect scripts and tapscripts, assemble and parse transactions, PSBTs and UTXOs, and handle common encodings used in the Bitcoin ecosystem. The distribution exposes convenient shortcut functions that load specific submodules so you can quickly instantiate the exact key or transaction class you need. This module is useful if you need to manipulate keys, addresses or transactions from Perl rather than run a full node, and it is designed to follow Bitcoin BIP standards and to be used alongside RPC clients when needed. It is maintained under the same license terms as Perl.

Data::Dumper::Interp is a user-friendly wrapper around Data::Dumper that makes Perl data structures easy to read and lets you interpolate pretty-printed variable values directly into strings via ivis and dvis, or format single values and lists with vis, avis and hvis. It formats output on one line when possible or wraps to your terminal width, never appends a final newline, shows printable Unicode characters nicely, labels code references with their sub names, and by default presents blessed objects in readable string form while providing options to reveal internals when you need them. The module offers abbreviated ref addresses with addrvis, a fluent OO API via visnew for per-call configuration, a flexible naming convention of modifier letters to generate variants on demand, and handy utilities for shell-quoting and key quoting. You can also plug its RefArgFormatter into Carp to improve tracebacks. Be aware that ivis and dvis evaluate expressions in the caller context using Perl debugger hooks so some corner cases can occur, for example @_ may look wrong after shift and certain lexicals in closures may not be visible, and multiple references are represented the same way Data::Dumper does unless you enable Refaddr. Recent notable changes include a 8.000 update that altered the meaning of the function-modifier letters B and O.

Google::Ads::GoogleAds::Client is the central Perl client for the Google Ads API that manages credentials, configuration, and access to every API service. It reads settings from a googleads.properties file or environment variables and lets you override values when creating the client. It includes handlers for OAuth2 web/desktop flows and for service accounts so you can set refresh tokens, JSON key files, or impersonated emails programmatically. Each Google Ads service is exposed as a method on the client, simplifying requests like search or mutate and returning service-specific objects for the API version you choose. You can control HTTP behavior with proxy, timeout, retry timing, and user agent options, inspect the last request and response, and toggle error handling with a die_on_faults flag which by default returns rich GoogleAdsException objects instead of immediately dying. The module should be loaded before other Google::Ads::* modules. Recent releases continue to add support for new Google Ads API versions and the latest change adds support for v23_2.

Config::Model::Itself is a companion to Config::Model that provides a read/write handler and a small editor for the meta-model files that describe configuration schemas, so you can inspect, modify and persist the very model that Config::Model uses to validate and edit configuration data. It exposes a simple API to load all model files from a directory, write them back while preserving directory structure, read and write model plugins, produce Graphviz dot diagrams of class relationships, and integrate with the cme UI tool or curses/Tk front ends for interactive editing and testing. The module is mature and actively maintained, and recent updates include dropping model annotations to align with upstream Config::Model changes. One known limitation is that test menu entries built from the application model cannot be updated dynamically so the cme tool must be restarted to pick up menu changes.

PGPLOTx::Constants supplies readable, named constants for the PGPLOT plotting library so you can use names like GREEN, SOLID, or NORMAL instead of numeric codes for colors, line and fill styles, fonts, symbols, axis options and plot units. It uses Exporter::Tiny so you can import individual constants, groups by tag (for example colors or fonts), or rename imports with an -as option to fit your coding style. Two helper routines, coerce_constant and list_constants, make it easy to build user-friendly interfaces by validating and normalizing user-supplied names and listing accepted names, including lower-case and hyphen/underscore aliases. The module is lightweight and focused on making PGPLOT-based code clearer and less error-prone. Recent releases added those UI helpers and fixed build issues while bumping the minimum Perl requirement to 5.22.

TOON is a small pure-Perl encoder and decoder for Token-Oriented Object Notation that exposes a simple, JSON-like API so you can convert Perl data structures to and from a compact text form. It supports scalars including null, true, false, numbers and quoted strings with JSON-style escapes, arrays, and objects with quoted or bareword keys that match [A-Za-z_][A-Za-z0-9_-]*. You can use it either as an object with methods to enable pretty printing, canonical (sorted-key) output and configurable indentation or via functional helpers like encode_toon and decode_toon, and parsing errors raise TOON::Error. This starter implementation is minimal and pragmatic and recent updates added parsing and encoding for tabular hashes plus documentation, a license file and a version flag in the included tooling.

Sietima is a lightweight, modern-Perl mailing list manager that reads a message from standard input, re-envelopes it using a configured return address, and delivers copies to a list of subscribers. It intentionally implements a small core and lets you add common mailing-list behaviors by composing roles, so you can enable features like avoiding duplicate deliveries, soft moderation for non-subscribers, List-* headers, reply-to handling, subject tagging, DMARC-aware no-spoofing, per-subscriber preferences, and header stripping without pulling in a monolithic framework. You configure it by constructing a Sietima object or by using the included command-line helper, and it sends mail using Email::Sender transports so it plugs into normal MTA workflows or .qmail-style piping. The module is a good fit if you need a simple, composable list manager for self-hosted lists or lightweight gatewaying, and the latest release adds a StripHeaders role to remove unwanted headers before delivery.

Module::Starter::PBP is a plugin for Module::Starter that generates a ready-to-use Perl distribution skeleton following the recommendations in Damian Conway's book Perl Best Practices. It uses a simple directory of plain-file templates for Build.PL, Makefile.PL, README, Changes, the main Module.pm and test files under t/, and automatically substitutes placeholders such as author, email, module name, year and build instructions. Setup is quick: run perl -MModule::Starter::PBP=setup to create your template directory and config entries, then run module-starter --module=Your::New::Module to produce a new module. The plugin integrates with your existing ~/.module-starter/config so you keep control of author, license and builder choices while getting a consistent, best-practice project layout. It requires Module::Starter, ships default templates based on Perl Best Practices, and is useful for anyone who wants to avoid handcrafting boilerplate and follow a recommended structure.

Dist::Zilla::PluginBundle::Author::GETTY is an opinionated, ready-made Dist::Zilla bundle that packages the tools and sensible defaults the CPAN author GETTY uses to build, document and release Perl distributions. It wires together versioning (Git::VersionManager or AutoVersion for task releases), PodWeaver, metadata helpers, Git checks and a post-release installer so you can release to CPAN with minimal configuration while still overriding details like author/authority, release_branch, or disabling CPAN uploads. The bundle also adds conveniences for XS and Alien-based modules, supports running scripts at various build and release points, and exposes flags such as no_install, no_makemaker, include_readme and adoptme plus IRC/contact metadata for generated SUPPORT sections. Recent updates made README.md excluded from release tarballs by default with an opt-in include_readme option and forward the commit_files_after_release setting to the version manager so files modified during run_before_release actually end up in the release commit. If you use Dist::Zilla and want a tested, configurable shortcut for packaging and releasing Perl distributions, this bundle is a practical starting point.

Music::Interval::Barycentric implements barycentric chord analysis for Perl, mapping chords expressed as pitch-class vectors into a geometric interval space so you can compare, transform and quantify them. It gives straightforward functions to compute a chord barycenter for a given chord size and scale, measure Euclidean-style distances between chords as well as cyclic and inversion-aware variants (orbit_distance and forte_distance), generate cyclic permutations, compute an evenness (consonance) index, and produce chord inversions. The API works with array references of pitch classes and defaults to three-note chords on a 12‑note scale, making the module useful for music theorists, algorithmic composers, visualization tools and any project that needs programmatic measures of chord similarity and balance. The recent 0.0402 release improves documentation and tests and updates the example evolve program.