CPANscan

Time::Moment is an immutable Perl class for representing an ISO 8601 date and time with an offset from UTC and nanosecond resolution across the range 0001-01-01 to 9999-12-31. It provides multiple constructors (new, now, now_utc, from_epoch, from_string, from_rd/jd/mjd and from_object), rich accessors and "with_" modifiers for every component, calendar-aware arithmetic and delta calculations, precision trimming, ISO-style parsing and strftime-style formatting, and built‑in serializers for Storable, JSON, CBOR and Sereal. The module is thread safe, interoperates with DateTime and Time::Piece for time zone handling, and explicitly does not account for leap seconds so each day is treated as exactly 86,400 seconds. Recent fixes include normalization of edge-case fractional seconds when creating from floating epoch values and a Year 2038 safety fix in now() by switching to 64-bit second calculations, making it robust for high-precision and long-range date/time work.

DateTime::Format::JP is a lightweight Perl formatter and parser for Japanese dates and times that makes it easy to read and print dates in Japanese styles, including era names, kanji numerals, full- and half-width digits, and a traditional time wording option. It offers two core methods, parse_datetime and format_datetime, accepts or returns decoded UTF‑8 strings, and uses a strftime-like pattern system with tokens for common Japanese formats such as era (%E), era year (%y), standard date/time (%c, %x, %X) and full Gregorian dates (%F). The module also provides helpers to convert between kanji, roman and zenkaku digits and to look up or select Japanese era objects, and it integrates with DateTime or DateTime::Lite so you can set it as a formatter for stringification. If you need to present or accept Japanese-formatted dates in a Perl program this module is a compact, purpose-built choice, and as of v0.1.7 the distribution now depends on DateTime::Lite.

Geo::IP2Proxy is a pure-Perl library for doing fast reverse lookups of IP addresses against IP2Proxy BIN databases to detect VPNs, open and web proxies, Tor exit nodes, search engine robots, data center ranges, residential proxies and other privacy or enterprise networks while returning useful metadata like proxy type, country, region, city, ISP, domain, usage type, ASN and AS name, threat tags, provider name and a numerical fraud score. It works from a local BIN file so you can open the database and call simple methods such as isProxy, getProxyType or getAll to get a one-shot report for IPv4 or IPv6 addresses. The underlying IP2Proxy database is updated daily and full datasets require a subscription, though IP2Proxy publishes sample BIN files and a limited free monthly LITE database for basic open-proxy detection. If you need to gate access, reduce fraud risk or add proxy-aware logic to authentication and logging flows, this module provides a lightweight, dependency-free way to integrate that intelligence into Perl applications.

Text::Treesitter::Bash is a Perl helper that uses the Text::Treesitter infrastructure to parse Bash sources and pull out the executable commands and call sites you care about, making it easy to locate what a shell script will actually run. It ships with the tree-sitter-bash 0.20.5 grammar and includes a built-in Security::Checker that flags common issues such as path traversal, dangerous flags, sensitive file access, risky environment variables, unquoted expansions, and missing absolute paths. If you need to build static analysis, linters, audit tools, or automation that reasons about shell behavior from Perl, this module gives you a focused, ready-made way to extract commands and surface likely security problems. This is the initial release and is intended to be extended and contributed to on its public repository.

Plack::Middleware::BlockHeaderInjection is a lightweight Plack middleware that defends PSGI applications from HTTP header injection by scanning response headers for disallowed control characters (ASCII 0-31), removing any offending headers and returning an error status (500 by default) when a problem is detected. It is especially useful if your app builds headers from user input, for example redirection locations or cookie values, and helps prevent attackers from forging headers such as referrer or cookie to bypass security checks. Configuration is minimal — you can change the status code returned — and the module requires Perl 5.24 or later.

Hash::SharedMem provides a fast, file-backed key/value store that multiple processes on the same host can map into memory and update without blocking one another, presenting an interface much like a Perl hash but restricted to octet (Latin-1) strings for keys and values and allowing complex structures only if you serialize them first (for example with Sereal). It stores its data in a directory of files that are mmap(2)-ed so readers and writers share memory and you get persistence while the OS is up, atomic single-key operations including an atomic compare-and-set, and snapshot handles that give a stable read-only view of the hash state. The module includes utilities to open handles with read/write control, enumerate keys or the whole hash, query sizes and counts, perform maintenance (idle and tidy) to limit resource use, and read per-handle event tallies for profiling. It is optimized for workloads where the whole dataset fits in RAM and will suffer if the filesystem is swapping heavily, and creation and on-disk consistency across OS crashes are not fully transactional so you should be cautious about ownership, permissions, and copying while writers are active. Recent releases mainly improve compatibility with newer Perl releases, refine behavior of tied-hash operations and counters, and include various robustness and test-suite enhancements.

Net::LibIDN2 is a Perl wrapper around the GNU libidn2 C library that makes it easy to handle internationalized domain names (IDNA2008), Punycode and TR46 rules from Perl code. It provides simple functions to convert domain names and labels between UTF-8, the local charset and ACE/Punycode, perform lookup and register-style conversions, and to decode ACE-encoded names back to Unicode. The module exposes flags for NFC normalization and TR46 transitional or non-transitional processing, returns libidn2 result codes for detailed error handling, and includes helpers to translate those codes to readable messages. If your application needs reliable IDN conversion or validation in line with modern IDNA standards this module is directly relevant, but note it requires the libidn2 library to be available at runtime and offers a version-check function to detect compatibility.

CPAN::Maker is a command-line tool and small toolchain for turning a Perl project into a CPAN-style distribution by locating your modules, scripts and tests, resolving dependencies, generating a Makefile.PL and assembling a tarball ready for upload. It prefers a YAML buildspec that describes paths, dependency files, extra files and metadata and can run the supplied make-cpan-dist bash wrapper to clone git repos, run dependency scanners (scandeps or Module::ScanDeps::Static), copy test and executable files and build the final tarball, while direct invocation will at minimum emit a Makefile.PL for you to tweak. The tool supports fine-grained options for dependency lists, min Perl version, inclusion of extra files, and logging, and environment variables let you preserve the generated Makefile.PL, skip tests or enable debug output for troubleshooting. In the recent 1.8.0 release the utility gained support for creating man-links so executables can point to a module's man page and fixed how script man pages are generated, making it a good fit if you want a repeatable, configurable way to prepare and package Perl modules for CPAN.

DateTime::Lite is a lightweight, drop-in replacement for DateTime that gives you the same public API while trimming dependencies and improving some performance and memory characteristics. It keeps accurate timezone handling by reading TZif binaries compiled with the official zic tool and storing zone data in a bundled SQLite database, offers an XS-accelerated core for the CPU-heavy calendar math, and supports full Unicode CLDR and BCP 47 locale tags so you can use complex locale strings and even infer an IANA zone from a "-u-tz-" extension. Error handling follows a no-die philosophy by returning exception objects and undef on failure, and the TimeZone subsystem includes optional process-level caching and GPS coordinate or abbreviation resolution for convenient timezone lookups. If you need a faster, lower-dependency DateTime replacement for scripts, CLIs, or services that still require correct DST and leap-second behavior, DateTime::Lite is a strong choice. The recent v0.6.4 update refreshes the bundled IANA data, adds an extended option that lets TimeZone->new accept common abbreviations like JST or EST and allows passing a hashref to new()/set_time_zone() for advanced options, and includes thread-safety and correctness fixes for tricky DST edge cases.

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.

Developer::Dashboard provides a single local home for day-to-day development by combining a lightweight browser UI, shell prompt integration, and a CLI that share the same runtime state. It lets you keep bookmark-style pages, notes, and executable helpers in one place, run repeatable collectors that cache command output for cheap live indicators, and surface those indicators in both the web UI and your prompt so health checks and status are fast and consistent. The distribution also includes file-opening helpers that understand Perl modules and Java classes, small data-query tools for JSON, YAML, TOML and properties, and a project-aware Docker Compose resolver, while layered runtime roots let project-local ./.developer-dashboard overrides sit above a shared ~/.developer-dashboard fallback. It is written in Perl but is language-agnostic in practice, installs via cpanm or the provided install script, and is extensible through isolated skills and user CLI hooks. The runtime is file-backed, shipped with sensible defaults and owner-only file permissions, and transient browser execution of arbitrary token payloads is disabled by default unless you opt in.

DateTime::TimeZone is the DateTime ecosystem's central time zone factory and base class that provides named and offset-based time zone objects you can use to get correct UTC offsets, Daylight Saving flags, and short display names for specific datetimes. It is mainly used through DateTime rather than directly, but it handles the heavy lifting of historical and future zone rules, floating and UTC zones, local zone detection on many platforms, and utilities for validating and listing IANA/Olson names and zones by country. The module includes helpers to convert between human offset strings and seconds, integrates with Storable to avoid bloating serialized data, and documents platform-specific addons for better local-zone detection on Windows and HPUX. If you run a pre-forking server it is a good idea to load needed zones in the parent process to save memory. This release follows the IANA/Olson 2026b database and includes up-to-date changes affecting British Columbia, Canada.

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.

Test::Smoke is a utility for automating the Perl core "smoke" testing workflow, letting you configure, build, and run the core test suite across multiple build configurations and platforms. It exports a configuration variable and a read_config helper by default and provides convenient high level routines to prepare a build environment, run the smoke runs, perform MANIFEST checks against the source tree, detect Windows builds, and mark patchlevels as smoke-tested. The module is aimed at core developers and release engineers or anyone who needs repeatable, automated testing of different Perl builds. It is free software distributed under the same terms as Perl.

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.

IPC::Manager provides a simple, flexible way to pass messages between processes on the same machine by hiding the transport behind a consistent API. You start a datastore with ipcm_spawn and share the small info string it returns so other processes can ipcm_connect and send or receive message objects or plain hashrefs, with JSON as the default serializer but pluggable serializers supported. The module can use multiple local transports such as filesystem message files, atomic pipes, Unix sockets, or database tables so you can pick a temporary in-memory style bus or a persistent store backed by SQLite, MariaDB, MySQL, or PostgreSQL. It also includes helpers for forking services and workers and options to control cleanup behavior and shutdown signaling, though nested services require care to avoid a race where a caller tries to contact a child before it has finished connecting. Overall it is a pragmatic, protocol-agnostic toolkit for coordinating and exchanging messages between local Perl processes.

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.