CPANscan

Dist::Zilla::PluginBundle::Starter is a ready-made bundle of Dist::Zilla plugins that sets up a minimal, sensible toolchain to build, test, and release Perl distributions to CPAN. It groups a curated set of plugins for generating metadata and READMEs, running pod and compile tests, pruning cruft, managing manifests and uploads, and more, while remaining unopinionated and easy to customize. You can pin a bundle revision to preserve behavior, choose an installer backend like MakeMaker, ModuleBuild, ModuleBuildTiny or DistBuild, enable managed_versions to sync and bump module versions on release, or ask for generated files to be copied back into your repository at release time. There is a git-focused variant, @Starter::Git, and a FAKE_RELEASE mode to exercise the release process without uploading. If you want a low-friction, configurable starting point for packaging Perl modules with Dist::Zilla, this bundle is a practical and flexible choice.

Time::Str is a focused Perl utility for reliably parsing and formatting timestamps across a wide range of standards and real-world formats. It gives you str2time to convert strings into Unix timestamps with optional fractional-second precision, str2date to extract validated components without forcing a timezone conversion, and time2str to render timestamps into ISO 8601, RFC 3339/2822, HTTP, SQL, ASN.1, iCalendar, ECMAScript, Common Log Format and several other common flavors, plus a permissive "DateTime" parser for many real-world textual forms. The API supports fractional seconds, configurable precision and an exact nanosecond override, timezone offsets and a pivot-year option for formats that use two-digit years, and it intentionally captures ambiguous timezone abbreviations without guessing offsets so callers can resolve them explicitly. Recent releases added optional XS acceleration for faster time2str formatting when a C99 compiler is available and refactored internals into smaller components while still falling back to pure-Perl when needed. Note the documented limitations: month and day names are English only, ISO week and ordinal dates are not supported, timestamps are limited to years 0001–9999, and str2time requires either a UTC designator or a numeric offset rather than unresolved abbreviations.

DMS::Parser::XS is the C-backed (XS) implementation of a parser for the DMS data syntax that serves as a drop-in, high-performance alternative to the pure-Perl DMS::Parser. It parses DMS source into Perl scalars, arrays, and hashrefs and can return a full Document structure with front-matter, comments, and original literal forms, while exposing the same public API so existing code can switch backends without changes. The module offers a lite mode that skips comment and literal-form tracking for maximum speed and can be roughly twenty times faster on large documents, plus functions for front-matter-only parsing, unordered-table decoding, and tier-1 document handling with higher-level validation done in Perl. It can re-emit DMS either preserving original forms or producing a canonical representation, and the C parser and its utf8proc dependency are vendored in the distribution so no external C libraries are required, though a C compiler is needed at build time.

DMS::Parser is the pure‑Perl reference parser for the DMS data format, turning DMS source into native Perl data structures plus small blessed sentinel objects for types that do not map cleanly to Perl such as booleans, integers, floats and several date/time kinds. You can parse just the body or request a full Document that preserves front‑matter metadata, comments and original literal forms for exact round‑trip emission with DMS::Parser::Emitter, and there is a lighter decode mode that skips comment/form tracking for roughly double the speed on large documents. The module also offers a decorator‑aware tier‑1 parse and returns helpful line:column diagnostics on parse errors. For much higher throughput on large files use the companion DMS::Parser::XS bridge. Note that recent 0.3.0 changes standardized the public API names to decode/decode_document and encode (old names remain as deprecated aliases).

Sidef is a Perl module that embeds the Sidef programming language engine into Perl so you can parse, compile and run Sidef code from your Perl programs. It exposes an easy API to execute Sidef snippets, compile Sidef to Perl for fast embedding, inspect and transform the AST, and tune performance with multi-level optimization and an optional DBM-backed compilation cache. The language itself is multi-paradigm with modern features such as first-class functions, pattern matching, lazy sequences, multiple dispatch, operator overloading and native arbitrary-precision integers, rationals and complex numbers, and Sidef integrates directly with the Perl ecosystem so you can require any CPAN module from Sidef code. Typical uses include embedding Sidef as a configuration or expression language, safe evaluation of user expressions, code generation and metaprogramming, and speeding repeated workloads by compiling once and reusing code. Installation requires standard C math libraries for full numeric support and optional DB_File or GDBM_File for caching, and you should be aware of a few limits noted by the author such as Unicode behavior depending on Perl, DBM cache not being thread safe without synchronization, and possible DBM record size issues for very large sources.

ExtUtils::CFeatureTest is a small utility for Perl XS authors that probes the C compiler and installed libraries on the build host and captures the results as a usable C header instead of a long list of -D flags and per-file #ifdef boilerplate. It can test for headers, compile and run small C snippets, try alternative include paths and linker options, and declare macros or add actual #include lines into a generated config header that your C sources can include directly. The module also exports discovered include paths and flags to ExtUtils::Depends so other modules can use them and provides convenience methods to mark features as required or optional during a Makefile.PL run. It is intentionally single-file and dependency-free so it is easy to ship in your distribution under inc/ExtUtils/CFeatureTest.pm and avoid system-wide upgrades breaking older builds. Recent changes in version 0.002 improved how the config_* attributes are organized and added fancier output for diagnostics.

Business::UDC is a compact Perl class for parsing, tokenizing and validating Universal Decimal Classification (UDC) notations used in library and bibliographic systems. You supply a UDC string and the module returns a token list, an abstract syntax tree, and a validation flag, and it can report descriptive errors with parameters to help diagnose problems. It is handy for cataloging, metadata processing, or any program that must interpret or check UDC codes, and it exposes simple methods such as new, tokens, ast, is_valid, source and error so you can plug parsing and validation into scripts and services. Recent changes make tokenization and validation more robust for real world data by adding support for alternative apostrophes and quotation marks, allowing more punctuation and spaces in names, and improving error messages and tests.

App::Netdisco is an open source, web‑based network management application that harvests SNMP and related data into a PostgreSQL database to help operators map, inventory and control their networks. It makes it easy to find a device by MAC or IP and see the switch port it lives on, change port state, VLAN or PoE settings, produce hardware and software inventory reports, and visualise topology with neighbour maps. The product ships as a web frontend plus a backend daemon for scheduled polling and interactive actions, is extensible with plugins and a DBIx::Class API, and offers container images and a public demo to try before you deploy. It requires Perl 5.10 or newer and PostgreSQL 9.6 or newer and includes guides for common OS installs. Recent releases have added API and monitoring endpoints including /api/v1/statistics and /health and /metrics, expanded power/PoE and power_modules visibility, and delivered a number of user interface and stability improvements.

Travel::Routing::DE::DBRIS is a Perl library for programmatically querying Deutsche Bahn's bahn.de itinerary service and returning structured journey results so your code can list connections, segments, departure and arrival times, stop names and useful flags like transfers or cancellations. It expects origin and destination as Travel::Status::DE::DBRIS Location objects and supports common options such as date/time, up to two required stopovers, language, modes of transit, passenger details for pricing, caching and custom user agents, making it handy for building trip planners, schedule lookups or command line tools that need German rail itineraries. The module returns Connection and Segment objects with accessible fields for times, stops and messages, and recent maintenance releases have adjusted the parser for bahn.de API changes and improved handling of cancelled segments, DST edge cases, compressed responses and evasions for an aggressive web application firewall. The author notes the project is still a work in progress and some advanced features such as complete fare handling, Deutschlandticket logic, bike carriage and reservation-only handling are not yet implemented.

Travel::Status::DE::DBRIS is an unofficial Perl client for Deutsche Bahn's bahn.de departure monitors and train information APIs that makes it easy to fetch station departure boards, search for stations by name or location, retrieve trip details and request carriage formation for a specific train. You can use it synchronously or with promises for nonblocking code, and results are returned as objects you can inspect for times, delays, line numbers and destinations. The module supports basic caching of realtime responses, an optional failure cache, filtering by modes of transit and a configurable number of intermediate stops, and it can also load prepared JSON for testing. It requires standard Perl web and date libraries and offers a developer_mode that prints requests and responses for debugging. The author notes the project is still a work in progress and recent releases address backend changes and service quirks such as stricter WAF behavior from bahn.de and updated API formats, with the 0.28 release adjusting for recent internal API changes.

Alien::cmake4 provides a portable way for Perl distributions to find, install, or build CMake version 4.x so your XS or external-build code can invoke a known cmake executable. It exports simple helpers and methods such as exe and bin_dir so you can add the CMake bin directory to PATH and call the cmake program from Perl. The module prefers binary "share" installs when prebuilt packages are available for Windows, macOS and common Linux architectures and can fall back to building from source on other platforms or when ALIEN_CMAKE_FROM_SOURCE is set. You can control install behavior with the standard Alien::Build environment variable ALIEN_INSTALL_TYPE and it integrates with the Alien::Build ecosystem and the Alien::Build::Plugin::Build::CMake plugin. Recent releases tightened build dependencies and added a minimal Perl version requirement and a glibc check for Linux binary installs to improve reliability.

PDF::FacturX lets you turn an existing visual invoice PDF into a standards-compliant Factur‑X / ZUGFeRD PDF/A-3 invoice by embedding a CrossIndustryInvoice XML file that follows the EN 16931 norm. It provides a single generate function that builds and validates the XML, wraps it into a PDF/A-3 envelope with the required XMP metadata and associated file relationship, and writes a PDF/A-3 output suitable for French and German e-invoicing workflows. The module supports the common Factur‑X profiles (minimum, basicwl, basic and en16931), validates against the official XSD, and defaults to validating XML before embedding. You will need Perl 5.20+, Ghostscript, and the usual XML and PDF Perl libraries, and the initial release also includes an sRGB ICC fallback and uses Ghostscript plus PDF::Builder to produce the PDF/A-3 output.

GDPR::IAB::TCFv2 is a Perl parser for IAB TCF version 2 consent strings that decodes a base64url encoded Transparency & Consent string into an easy to use, immutable object so you can read who gave consent, when and for what. Use Parse to validate and load a TC string and then call methods to fetch metadata like version, creation and update timestamps, CMP id and version, consent language and vendor list version. The object exposes checks for purpose consent and legitimate interest, vendor consent and legitimate interest, special feature opt ins, purpose one treatment, publisher country and publisher restrictions, and it can decode a Publisher TC section when present. Parse supports a strict mode for format validation, a prefetch option to help with range-based vendor sections and a configurable TO_JSON output to produce compact or verbose JSON with customizable date and boolean formats. The module will die on invalid input but otherwise gives a convenient API for integrating TCFv2 checks into applications that need to respect consent signals. Recent releases added a unified subcommand CLI and fixed a CLI parameter bug along with improvements to the CLI help and overall quality checks.

Compress::Stream::Zstd is a lightweight Perl binding to the Zstandard compression library that gives you simple compress and decompress functions for in-memory buffers, accepting scalars or scalar references and returning undef on error. It is a fork of Compress-Zstd with a few streaming robustness fixes to ensure it works well with IO-Compress-Zstd, and it exposes a few constants such as version and compression level limits. Use it when you need fast, modern compression from Perl with a minimal API and a permissive BSD-style license.

File::Raw::Gzip is a lightweight plugin that adds transparent gzip/zlib/raw-deflate support to File::Raw, letting you read compressed files as regular strings and write compressed files with a single option. Once loaded it registers the "gzip" plugin so file_slurp/file_spew and similar File::Raw helpers will automatically inflate on read or deflate on write, with configurable compression level, mode (gzip, zlib, raw or auto for decoding), chunk size and advanced tuning like strategy and memory level. It also supports streaming each_line over compressed files without slurping the whole file and composes cleanly with other File::Raw plugins for slurp/spew chains, although per-record dispatching is not applicable to gzip streams. The module is a thin binding to libz so you need the system zlib development package to build, and version 0.01 is the initial release.

Test::SPDX::Coverage is a small test-harness helper for Perl projects that scans the files listed in your MANIFEST and checks that each matched source file contains a SPDX-License-Identifier comment and that the identifier is valid according to the License::SPDX database. You drop it into your test suite and call spdx_coverage_ok(), and it will read your MANIFEST for files matching a pattern (by default .pm, .pl, .cgi), look for a line like "# SPDX-License-Identifier: MIT" within the first N lines, and validate the declared license string via License::SPDX. The exported spdx_coverage_ok function accepts options such as which manifest to use, the filename match regex, how many lines to scan, and a diagnostic level. This module is useful for projects that want automated, CI-friendly checks that source files carry proper SPDX metadata and is distributed under the MIT license.

Geo::Address::Parser::Country is a Perl module that normalizes the last comma-separated component of a place string into a canonical country name. It is built to tolerate messy, abbreviated, or historical place names often found in genealogy data and poor-quality imports. Resolution starts with a direct lookup of common variants and historical names, then checks US states, Canadian provinces in English and French, and Australian states via Locale::US, Locale::CA and Locale::AU, and finally falls back to Locale::Object::Country and optionally Geo::GeoNames if you supply one. You construct the resolver with prebuilt locale objects and resolve() returns a hashref containing the resolved country, the possibly amended place string, an array of warnings, and an unknown flag instead of emitting errors. Note two documented caveats: the direct lookup maps "NL" to Netherlands which can conflict with the Canadian province code for Newfoundland and Labrador, and Geo::GeoNames uses AUTOLOAD which may cause simple constructor validation to reject a real Geo::GeoNames object unless you wrap or subclass it.

Graphics::Toolkit::Color (GTC) is a high-level Perl API for creating, converting and composing colors and palettes as immutable objects. It accepts many input forms including CSS and named colors, hex codes, numeric tuples and custom ranged or raw values, and it can output values in multiple formats or canonical names. You can measure perceptual distance, check if a color is in gamut, convert between spaces, and produce related colors such as mixes, gradients, complements and clusters for palette generation. The module defaults to RGB for screen work but supports many perceptual and wide-gamut spaces, and the recent 2.1 release added a large set of professional color spaces plus improved gamut checking and raw value handling for advanced workflows. Lightweight helpers color and is_in_gamut are exportable for quick scripting and optional external color-name modules extend available naming schemes.

CGI.pm is a long‑standing, full‑featured Perl module for building classic web scripts that need to parse form input, handle file uploads, read and write cookies, emit HTTP headers and redirects, build and preserve query strings, and inspect common request environment variables. It works in plain CGI as well as under mod_perl and FastCGI, is battle‑tested on thousands of sites, and offers both object and function styles so you can fetch params, generate headers, and save or restore script state with simple calls. The distribution has been removed from the Perl core so you must install it separately, and its built‑in HTML generation helpers are no longer maintained so template engines are recommended for page rendering. CGI.pm still provides useful protections and hooks for upload handling, POST limits, and debugging, making it a solid choice for maintaining legacy CGI apps or writing simple server scripts, while newer web frameworks are generally preferred for modern, scalable application development.

DBIx::Lite is a lightweight, chainable ORM for Perl that lets you build SQL and work with database rows using simple method chains without requiring a full schema upfront. It can run disconnected to just generate SQL or connect to a database via DBI/DBIx::Connector and supports lazy SQL generation, joins, relationships, automatic column accessors, paging with Data::Page and SQL::Abstract style conditions. You can provide a DBI handle or connection info, and optionally declare primary keys and relationships in a small schema to enable convenience methods like find and insert_related. The module aims to give most of the useful ergonomics of a full ORM while staying minimal and easy to adopt for scripts and applications that want expressive query construction without the overhead of heavier systems.

Crypt::SecretBuffer gives you a SecretBuffer object for holding sensitive byte data outside Perl's normal scalar heap so passwords and keys are less likely to be copied into logs, temporary buffers, or long-lived memory. The buffer lives in XS memory that Perl does not normally inspect, is wiped before being freed or reallocated, and is engineered to let you read from TTYs with echo disabled, feed secrets to external commands via pipes without creating Perl scalars, and hand raw bytes directly to XS code via unmasking helpers or a C API. It also provides convenient and safe-ish operations for manipulating secrets such as splice, substr, length-prefixed encoding, file IO, a memcmp that runs in constant time relative to the shortest input, and Span objects for parsing, while stringification is masked by default to avoid accidental exposure. The module is explicit that this reduces accidental leakage rather than making Perl the ideal environment for long-lived secret management, and recent 0.024 changes add timeout, resumable state, and utf8 support to append_console_line, add a len alias for length, and expand scan character class parsing while noting a semi-breaking C API signature change for callers that compiled against the headers.

Plack is a lightweight Perl toolkit that implements the PSGI specification and acts as the glue between web applications, frameworks and web servers. It gives you server adapters so the same app can run under CGI, FastCGI, Apache or standalone servers, a loader and plackup command to run .psgi application files, a middleware system and a small builder DSL to stack common features like logging, static file serving and compression, and convenient Request and Response wrappers to work with the PSGI environment. Plack also includes testing helpers to exercise applications with real HTTP requests without starting external servers which makes development and debugging easier. If you build or deploy Perl web apps or frameworks Plack lets you mix and match servers and middleware and standardizes how apps are run and tested. Note that the project recently deprecated Plack::Middleware::XSendfile due to security design concerns so check the changelog for migration guidance.

Win32::EventLog lets Perl programs interact with Windows Event Logs so you can open, read, back up, clear and write event records from scripts. It exposes an EventLog object with methods to connect to local or remote logs, read entries sequentially or by offset, back up or clear a log and report new events, and it provides a helper to format an entry's message text. The module understands Windows concepts like event type, category, event ID, raw data and insertion strings and exports useful constants to simplify code. It is a practical tool for Windows system administrators and developers who need to automate log collection, auditing or alerting with Perl. Recent fixes improved read reliability by correcting a skipped-record bug in sequential reads and by refactoring read caching for seek mode.

Win32::NetAdmin is a Perl module for administering Windows network accounts and groups from scripts, letting you create, delete and modify users and groups, check membership, change passwords, and enumerate domain controllers, servers, transports, logged-on users and local drives. Most functions accept an optional server name so you can target the local machine or a remote host, and they return false on failure with Win32::NetAdmin::GetError() available to retrieve the Windows error code. This module is useful for automating Windows account and group management but many operations require administrative privileges on the target machine. The project is actively maintained and the latest release fixes a memory leak and improves build and test reliability on Windows Server.

Win32 is the standard Perl interface to many Windows API routines, giving Perl scripts easy access to Windows-specific functionality without writing C or XS code. It wraps common tasks such as creating and copying files and directories, converting and querying path names (long, short, ANSI and Unicode), getting OS and filesystem details, reading process and thread IDs, inspecting privileges and administrative status, working with console code pages and system metrics, generating GUIDs, initiating shutdowns, showing message boxes and even a simple HTTP file downloader. The module is useful whenever you need to query or control aspects of the host Windows environment from Perl, and it includes some higher-level helpers like GetOSName/GetOSDisplayName and GetFolderPath. Be aware that path-related functions may return Unicode or ANSI names and that short (8.3) path support is system- and volume-dependent so results can vary on modern Windows, and a few legacy entry points are deprecated. Recent updates modernize packaging and documentation and improve detection of newer Windows releases and CPU architectures.

Spreadsheet::Edit is a Perl tool for loading, inspecting, transforming and saving tabular data from CSV files or common spreadsheet formats with a friendly, scriptable API. It gives you a sheet object and a functional interface where each row behaves like both an array and a hash so you can refer to columns by index, letter, title or user-created alias. Typical uses include scanning or applying a block to every data row, random access, inserting, deleting, moving or splitting columns, sorting rows, transposing tables, and writing back to CSV or spreadsheet files. For convenience it can tie package variables to columns so you can write mail‑merge or row-oriented code that reads and writes column variables directly. The module also auto-detects title rows, CSV encodings and column formats and recent improvements focus on safer CSV handling and format detection so values like leading-zero zip codes survive round trips to spreadsheet formats. One practical caveat is that reading non-CSV spreadsheets relies on external tools and can fail if LibreOffice/OpenOffice is running, so CSV input is the most robust option.

Test::Mockingbird is a Perl testing utility that makes it simple to replace and observe parts of your code so you can write focused unit tests. It provides mocking to swap in custom implementations, spies that record every call and its arguments, dependency injection to substitute collaborators, and scoped guards that automatically restore mocks when they go out of scope. Handy helpers let you make a method always return a value, throw an exception, yield a sequence of values, or act only once, and there are unmock, restore, and restore_all routines to clean up test state. Non‑intrusive diagnostics give a readable and structured view of active mock layers and where they were installed to help debug complex test setups. In the recent 0.09 release mock_scoped was fixed so it no longer creates duplicate diagnostic entries and now supports multi‑method guards that restore several mocks atomically, making scoped mocking more reliable and convenient.

IRI is a Perl module that implements Internationalized Resource Identifiers (IRIs) as defined by RFC 3987 and makes it easy to parse, serialize, inspect and resolve IRIs in your code. It gives you an object you can query for scheme, host, port, user, path, query and fragment, resolve relative IRIs against a base, obtain or set query form data, and produce absolute or relative string forms. The module can defer parsing until a component is actually accessed to save work on simple use cases, and it includes helpers like query_form and set_query_param for manipulating query data and rel to compute a relative IRI. Use IRI when you need robust handling of non-ASCII URLs, link resolution, or IRI normalization in web applications or tools. Recent maintenance updates fixed a trailing-newline parsing bug and corrected packaging metadata, and earlier releases added lazy parsing and relative-IRI support.

Graphics::Framebuffer is a Perl library for drawing directly to a Linux console framebuffer, giving you pixel plotting, lines, shapes, gradients, image blitting, TrueType text and simple animation without the overhead of X. Its methods take hashref parameters and cover everything from single-pixel plotting and clipping to filled polygons, rotated and scaled blits, color conversions and basic mouse polling, while optional Imager and Inline::C acceleration speed up heavy operations. The module runs in exclusive graphics mode on framebuffer devices and will fall back to an emulated in-memory screen for development, but it will not work inside X/Wayland and prefers open source drivers such as Nouveau rather than proprietary DRM drivers. It is CPU bound in pure Perl so 24/32 bit modes and enabling acceleration improve performance, and the author documents caveats for functions like flood fill and TTF rendering. If you need simple, low-level console graphics for embedded Linux, media players or kiosks, this module is a practical, well documented choice.

Router::Ragel is a high-performance URL router that compiles route patterns into a single Ragel-generated finite state machine and emits C via Inline::C so matching is a fixed-cost DFA walk rather than a per-route regex scan. It supports static segments, named placeholders, typed constraints and inline placeholders inside segments, and you can use a function form of match to minimize call overhead. You must call compile to build and dlopen the generated machine before matching, and for best deployment behavior you should compile in the parent process or warm the Inline::C cache to avoid per-worker compilation. The router matches byte strings exactly and requires patterns to start with "/", it treats UTF-8 strings as bytes, adding routes after compile invalidates the compiled matcher and requires recompilation, and pattern validation is strict. Recent 0.02 adds typed and inline placeholders and tighter compile-time validation.