CPANscan

Net::Statsd::Lite is a simple Perl client for sending StatsD metrics that implements the StatsD Metrics Export Specification and can pack multiple metric lines into a single UDP packet. It offers convenient methods for counters, meters, gauges, timings/histograms and sets, supports buffered sending with optional autoflush and manual flush, and provides secure_set_add to HMAC-hash sensitive values before sending so you can record identifiers without exposing them. The API is easy to subclass to add tagging or other extensions, you can configure the socket directly and the module now uses IO::Socket::IP by default, and it performs validation on metric names and values to reduce the risk of metric-injection attacks. It requires Perl 5.20 or later. Recent releases focused on hardening and usability by switching secure hashing to the core Digest::SHA, tightening input validation to address CVEs, and making the socket explicitly configurable.

Dist::Zilla::Plugin::UsefulReadme is a Dist::Zilla plugin that builds a README for your distribution by extracting and combining selected =head1 POD sections from your main module, letting you include only the useful bits rather than dumping all module documentation. You pick which headings to include and the output format, with support for plain text, POD, Markdown, GitHub-flavored Markdown or a custom parser, and you can control filename, encoding, phase and output location from dist.ini. The plugin understands Pod::Weaver readme regions, can generate sensible fallback content for version, requirements, installation and recent changes when those sections are missing, supports appending or prepending snippets to generated sections, and can register needed developer prereqs for the chosen output type. Written as a successor to Pod::Readme and designed to sit well in Pod::Weaver-based workflows, it makes README generation configurable and repeatable for modern Dist::Zilla users. Note that v0.6.0 bumps the minimum Perl requirement to v5.24 and updates the code and build toolchain accordingly.

Net::CIDR::Set is a Perl module for representing and manipulating sets of IP addresses in a natural, set-oriented way. It accepts CIDR blocks, arbitrary start-end ranges, or individual addresses and will merge overlapping ranges for you, and it supports the usual set operations such as membership tests, union, intersection, xor, difference, complement and inversion. You can iterate over addresses, compact CIDR blocks or raw ranges and export results as arrays or formatted strings, and it handles both IPv4 and IPv6 (but not mixed in the same set unless you explicitly choose a coder). The module is handy for access control, network inventory, address summarization and related tasks, but be careful when expanding whole ranges into address arrays because those can be very large, especially for IPv6. It requires Perl 5.14 or later and the project is maintained on GitHub.

Perl::Critic::Policy::BuiltinFunctions::ProhibitForeach is a tiny, opinionated Perl::Critic rule that flags any use of the 'foreach' keyword and enforces the use of 'for' instead to keep loop style consistent across a codebase. It has no special configuration beyond the usual Perl::Critic options, so you add it when you want a single, consistent loop keyword enforced automatically. The 0.02 release modernized the test suite to the standard .run format and added explicit pass and fail cases for the prohibition.

Perl::Critic::Policy::ControlStructures::ProhibitBareBlockLoopControls is a Perl::Critic policy that helps you avoid subtle bugs and confusing control flow by flagging uses of the loop-control keywords next, last, and redo when they appear in blocks that are not actual loops or where their meaning is ambiguous. It recognizes that bare "{ }" blocks, do { }, anonymous subroutines, eval { }, and map/grep blocks do not behave the same as real while/for loops and that unlabeled loop controls in those contexts can exit the wrong block or do nothing obvious. The policy is configurable per keyword to forbid the keyword, require an explicit label, or allow it, and you can also override behavior for specific block kinds such as bare_block and do_block so the checks match your coding style. The recent updates adjusted the package name to help CPAN indexing and improved the clarity of violation messages and tests in earlier releases.

Switch::Declare adds a real, lexically scoped switch/ case keyword to Perl that is parsed at compile time and turned into ordinary Perl operations so you get readable switch syntax with performance comparable to hand‑written if/elsif chains. It evaluates the scrutinee exactly once, stops at the first matching case, and supports both statement and expression forms so a switch can either run a branch or yield a value. Cases accept a small, predictable set of pattern kinds: numeric and string literals, regular expressions, inclusive ranges, literal lists for membership tests, and predicate callbacks or inline subs that close over surrounding lexicals. For string-keyed, constant mappings with several arms the module automatically emits a single compile-time lookup table for O(1) dispatch which is noticeably faster than a long chain of comparisons. The keyword is active only inside use Switch::Declare scope so it never collides with other code, it has no external dependencies and targets core Perl 5.14 or later, and the initial 0.01 release documents these features and performance-oriented design choices.

Perl::Critic::Policy::ControlStructures::ProhibitBareBlockLoopControls is a linting rule for Perl that flags uses of next, last, and redo inside blocks that are not true loops or where their behavior is confusing, such as bare { } blocks, do { } blocks, anonymous subroutines, eval blocks, and map/grep blocks. It helps prevent subtle and hard to spot bugs by enforcing clearer control flow and by making the programmer explicitly target the intended loop when needed. The policy is configurable per keyword and per block type so you can forbid a keyword require a label for it or follow global settings, with sensible defaults that forbid next and redo in non-loops and require labels for last while treating do blocks as forbidden by default. Use this module when you want stricter, configurable checks to avoid ambiguous loop control usage and make your Perl code safer and easier to read.

PPIx::Regexp provides a safe, read-only parser and navigable parse tree for Perl regular expressions, much like PPI does for Perl code, so you can turn a regex or a PPI regexp token into an object you can inspect, query, and round-trip back to the original text. It is aimed at tools that need to analyze regexes rather than execute them, offering methods to extract regexes from PPI::Document objects, list capture names, inspect modifiers, get the pattern and replacement portions, and cache parse results for reuse. The constructor accepts strings or PPI tokens and supports options such as default modifiers, character encoding, strict re parsing, and optional indexing of element locations so parse positions match the surrounding document. PPIx::Regexp intentionally does not provide heavy-weight mutation or operator overloading and focuses on producing a stable, modern parse that tracks relevant Perl regexp changes across versions. Be aware that static parsing has limits, so ambiguous constructs and dynamic interpolation can be interpreted heuristically and nonstandard Perl extensions or source filters may not be recognized. Recent changes are mostly maintenance and documentation updates, and postfix dereference handling has been standardized so the formerly supported postderef constructor flag has been removed.

PPIx::QuoteLike is a focused Perl parsing utility that breaks down string literals and string-like constructs so you can inspect their parts, detect whether they interpolate, and extract interpolated variables for tools such as linters and code analysers. You can feed it a raw string or a PPI::Element and it returns a parsed object with methods to get content, delimiters, start and finish tokens, child elements, locations, and whether the string interpolates, plus helpers like find() and perl_version_introduced() to detect feature usage. It understands modern features such as indented here-documents and postfix dereferencing and integrates with PPI for richer context, but it is still a static parser so it cannot handle every dynamic or nonstandard syntax change introduced by external modules. The variables() helper is provided but discouraged for complex cases, and recent releases removed a deprecated postderef argument while largely making administrative updates including a SECURITY policy and licensing metadata with no functional changes.

Business::KontoCheck is a Perl XS wrapper around the konto_check C library that validates German and Austrian bank account numbers and related identifiers. It provides functions to check account check digits for German BLZ-based accounts and Austrian accounts, validate IBAN and BIC, and generate or read compact lookup tables (LUT files) created from Bundesbank or Austrian INPAR data. The module also lets you look up bank metadata such as name, short name, postal code, city, BIC, branch counts and successor BLZ entries, convert numeric status codes into readable messages with selectable encodings, run flexible searches across the LUT by name, BIC, PLZ or complex multi-field queries, and rebuild or customize LUT files for fast local lookups. Note that LUT generation uses a modern compressed format and older formats are deprecated, the Austrian LUT generator is not thread safe and some features require the official input files or optional compression libraries. The Perl glue code is distributable under the same terms as Perl while the underlying C library is LGPL.

Mojolicious::Plugin::Qooxdoo is a Mojolicious plugin that makes it easy to host Qooxdoo web frontends and their JSON-RPC backends from a Perl app. It installs the routes and static asset handlers you need and provides a JsonRpcController base class you can subclass to implement server-side RPC methods, with simple options to set a URL prefix, path, controller class and namespace. During development it can serve your Qooxdoo source directly by flipping an environment variable so POST callbacks still work, while in production it will serve the generated build from your public directory. The plugin supports asynchronous responses and Mojo::Promise, keeps error details out of client responses by default, and warns about verbose debug logging. A recent 1.1.0 update added full JSON‑RPC 2.0 support while preserving the legacy qooxdoo protocol; the dispatcher auto-detects the envelope and routes requests to the appropriate handler so you can use modern RPC semantics without breaking older clients.

WWW::Mechanize is a mature Perl library that gives you a programmatic browser for automating web interactions, letting you fetch pages, follow links, fill and submit forms, manage cookies and history, and handle SSL, proxies and HTTP authentication all from a simple object interface. It builds on LWP::UserAgent so you can use low level HTTP features when needed while benefiting from high level helpers for finding links, images and form controls, which makes it handy for writing web scrapers, automated testers and integration scripts that interact with HTML pages. It is designed for reliability and testability and integrates easily with Perl testing modules, but it does not execute JavaScript so sites that rely on client-side scripting will need a different tool. In the most recent release a bug was fixed so link extraction no longer drops links that follow an unclosed <a> tag, improving robustness when parsing imperfect HTML.

Travel::Status::DE::DBRIS is an unofficial Perl client for Deutsche Bahn's bahn.de departure monitor and train information APIs that makes it easy to fetch station departure boards, search for stations by name or geographic coordinates, retrieve trip details and request carriage formation for a specific train. It offers both blocking and non‑blocking interfaces, integrates with promise libraries such as Mojo::Promise and Mojo::UserAgent, and returns rich objects for departures, journeys and formations so you can format or process results in your application. The module supports caching of realtime responses and an optional failure cache, can load prepared JSON for testing, and provides options to limit transit modes and the number of intermediate stops returned. Recent updates fix a 10 second delay caused by Akamai BMP and add Brotli and newer HTTP::Message dependencies, while earlier changes add randomized user agents and extra headers to reduce the chance of being rate limited by Deutsche Bahn's WAF. The author notes this is a work in progress and warns that aggressive upstream rate limiting means you should use caching and avoid overly frequent requests.

Travel::Routing::DE::DBRIS is a Perl client for the German rail operator bahn.de that fetches itinerary suggestions and schedules between two locations. You create an instance with Travel::Status::DE::DBRIS::Location objects for origin and destination and the module returns Connection objects that describe complete journeys with segments, times and transport details. The constructor supports options for a specific departure datetime, intermediate stops, language, transit modes, passenger types for pricing, HTTP user agent and response caching, and you can call errstr to detect HTTP or service errors. Developer mode prints raw requests and responses to help debugging. The module is useful for building schedule-aware query tools and price-aware journey lookups and is actively developed, though still a work in progress.

Monitoring::Sneck is a small helper module for the sneck utility that runs Nagios-style checks and emits LibreNMS-friendly JSON for use with SNMP extend. It reads a simple text config where you set environment variables, named checks and optional debug-only checks, performs variable substitution, executes each command while capturing stdout, stderr, exit code and run time, and returns a structured hash with per-check details plus aggregate counts for ok, warning, critical, unknown and errored checks. The module is intended to back the sneck script rather than serve as a general-purpose library and is designed for cron or snmpd extend usage with options for caching, quiet mode and locking. Recent releases added run timing metrics and improved error handling, and the 1.4.0 release fixed packaging by adding a missing Proc::PID::File dependency for locking support.

Finance::Tiller2QIF is a command-line tool and small Perl library that converts Tiller Money CSV exports into QIF files you can import into personal finance programs like GnuCash, KMyMoney, Quicken and others. It works in three simple stages: ingest parses the Tiller CSV into a local SQLite database, map applies a readable line-oriented mapping file to translate Tiller categories into your account or category names and to suppress duplicates, and emit writes the resulting transactions out as QIF. The tool supports a JSON config file or command-line options, previewing the results before export, checkpointing the database for safety and, in the most recent release, an option to revert to that checkpoint when confirming a run. There is also a qifdate option to accommodate date formats required by some importers. If you want to automate this workflow from code the module exposes the ReadCSV, Map and WriteQIF submodules as examples for programmatic use.

Mojo::PrettyTidy is a conservative formatter for Mojolicious ".html.ep" templates that tidies up layout and whitespace to make templates easier to read and maintain. It aims to make minimal, safe changes so your template logic and behavior stay intact instead of performing aggressive rewrites. If you work with Mojolicious templates and want a straightforward way to enforce cleaner, more consistent formatting this tool is relevant, and command-line usage is documented in Mojo::PrettyTidy::Manual.

Dist::Mgr is a toolkit for Perl authors that automates the tedious parts of preparing, testing and releasing a CPAN distribution, handling everything from creating a module skeleton to tagging, pushing and uploading the release. It integrates with Git and GitHub, installs GitHub Actions CI configs and README badges, manages Makefile.PL metadata, keeps your Changes and version numbers in sync, generates MANIFEST and test scaffolding, updates copyright years and can build and upload a CPAN tarball for you. The distribution assumes ExtUtils::MakeMaker style Makefile.PL projects and GitHub repositories so it is most useful to authors who publish modules on GitHub and PAUSE. Recent updates include a fix for a CI command line bug, better support for newer Module::Starter versions, more precise version bumping, improved copyright year handling and a raised minimum Perl requirement to 5.14.

Mail::DMARC is a Perl toolkit that implements the DMARC email authentication standard so mail servers and filters can check whether a message is legitimately from the domain it claims to be from. You give it simple metadata about a received message such as the envelope sender and recipient, SPF and DKIM results or a Mail::DKIM::Verifier object, then call validate to get a Mail::DMARC::Result that tells you whether the message passed DMARC and what disposition the sender domain requested, for example none, quarantine, or reject. The distribution includes a PurePerl implementation, an optional libopendmarc XS binding, SQL-backed report storage tested with SQLite, MySQL and PostgreSQL, and command line and HTTP utilities to view, send and receive aggregate reports. It aims to follow the DMARC specification and common best practices, and is designed for use inside MTAs, spam filters like SpamAssassin, and reporting systems for senders and operators. Note that enabling the full reporting features brings extra dependencies, but basic validation is lightweight.

RPi::WiringPi is a Perl wrapper that makes it easy to control Raspberry Pi hardware from Perl programs by sitting atop the wiringPi library and WiringPi::API. It exposes a Pi object that manages GPIO pins using Broadcom (BCM) numbering and provides ready-made interfaces for common devices and buses such as ADCs, DACs, OLED/LCD displays, RTCs, EEPROM, I2C, SPI, serial, servos, shift registers and common sensors so you can grab a device object and start reading or driving hardware without low level plumbing. The module keeps a registry of pins and shared metadata so multiple scripts can cooperate and so that pins and peripherals are reset to safe defaults automatically on normal exit, crashes or trapped signals, which simplifies cleanup and avoids leaving hardware in an inconsistent state. It also offers a robust interrupt and background-task API including polled dispatch (wait_interrupts/dispatch_interrupts), a blocking dispatch loop, optional signal-driven auto-dispatch, background interrupt workers and a worker() helper for recurring forked or threaded tasks. Note that wiringPi must be installed and the distribution recently upgraded to WiringPi::API 3.18, which brings a redesigned interrupt dispatch model with callbacks running in your Perl interpreter, improved fork-aware cleanup and Pi 5 pin-restore fixes.

RPi::SysInfo is a lightweight Perl module that fetches live hardware and system information from a Raspberry Pi, offering simple methods to read CPU and memory usage, core temperature, GPIO pin status, network and filesystem details, the active config.txt, and a consolidated Pi hardware/OS summary. You can use it as an object or import convenience functions, and it prefers modern Raspberry Pi OS tools but gracefully falls back to legacy commands so it works across Pi 3, 4 and 5 and many Linux systems. The module now includes pi_model to return a normalized board name from the device tree with a /proc/cpuinfo fallback, reports camera status via libcamera when the old vcgencmd probe is missing, and falls back to the kernel thermal zone for temperature and to ip addr when ifconfig/net-tools are absent. If you need quick, programmatic access to Raspberry Pi runtime and hardware facts from Perl code, this module provides a pragmatic, well-tested interface that adapts to different Pi models and OS releases.

RPi::StepperMotor lets you control a common 28BYJ-48 stepper motor through a ULN2003 driver from a Raspberry Pi using a simple object interface. You create an object with the four driver pins and then call cw or ccw with a degree value to turn the shaft, while adjusting speed mode between 'half' for finer steps and 'full' for faster motion and tuning the step delay to change the motor pace. The module can also drive the motor via an MCP23017 GPIO expander if you need more pins, supports naming multiple motors for clarity, and provides a cleanup method to reset GPIOs when you are done. A small command line tool is included for quick control from the shell. This is a lightweight, practical choice for adding precise, scriptable stepper motion to Raspberry Pi projects.

RPi::Serial is a lightweight Perl module that gives you simple read and write access to a UART serial port, making it easy to send and receive bytes from devices connected to a Raspberry Pi or other Unix-like systems. It opens a specified device at a chosen baud rate and provides straightforward operations for reading a single character or a fixed number of bytes, writing a character or a string, flushing buffers, checking how many bytes are available, and closing the port. If you plan to use the Pi's GPIO pins 14 and 15 as a serial interface be sure to disable the Pi's built-in Bluetooth by adding dtoverlay=pi3-disable-bt-overlay to /boot/config.txt and rebooting, otherwise the GPIO serial will not work. Recent releases removed the external WiringPi dependency by incorporating low-level code into an included XS component, which simplifies installation and can improve performance and reliability.

Amazon::S3::Lite is a compact, dependency-light Amazon S3 client that implements the common operations you actually need in Lambda functions and small scripts, such as listing buckets and objects, streaming downloads, simple uploads, server-side copies, deletes, and basic bucket creation. It is designed for minimal cold-start and small container images by building on HTTP::Tiny and Amazon::Signature4::Lite rather than LWP, it returns parsed Perl hashrefs for results and has built-in support for environment, IAM and rotating Lambda credentials so it works smoothly in serverless contexts. This module is not a full replacement for Amazon::S3 or Net::Amazon::S3 and does not aim to implement multipart uploads, presigned URLs, complex ACLs or advanced versioning features, so pick it when you want simplicity and small footprint rather than exhaustive S3 coverage. Recent releases refined bucket notification support and templating, fixed parsing issues, and added create_bucket and notification configuration methods to make wiring Lambda and SQS triggers easier.

RPi::OLED::SSD1306::128_64 is a simple Perl driver for 128x64 SSD1306-style OLED screens on a Raspberry Pi that lets you draw pixels, lines, rectangles and text over I2C and control basic display settings like dim and invert. It talks to the display through wiringPi (requires wiringPi 2.36 or newer) and exposes a small API for buffering graphics and text and then flushing them to the screen with display(); the module is a singleton and defaults to the very common I2C address 0x3C. If you need to show small status readouts, simple dashboards or custom monochrome graphics from Perl on a Pi, this module gives you the primitives you need without heavy dependencies or complexity. Note that recent changes make packaging easier by allowing the Makefile.PL wiringPi version checks to be bypassed via RPI_DIST_RELEASE=1 so release tarballs can be prepared on non-Pi machines.

RPi::LCD is a lightweight Perl module for driving common character LCD panels (2 or 4 rows, 16 or 20 columns) from a Raspberry Pi over the GPIO pins. It supports both 4‑ and 8‑bit wiring, expects you to supply the RS, strobe and data pin mappings, and provides simple methods to initialize the display, move the cursor, clear or toggle the screen, enable or blink the cursor, define user characters, and write strings or single characters; there is also a low‑level send_cmd for raw LCD commands. The module is standalone but interoperates with the RPi::WiringPi ecosystem so you get safe cleanup when used through that library. Recent updates ensure new() now respects the RPI_PIN_MODE environment variable so it no longer forces the pin numbering scheme unexpectedly, and dependency versions were bumped for WiringPi::API and RPi::Const. If you want an easy Perl API to control a standard character LCD from a Raspberry Pi, this module is a straightforward choice.

RPi::HCSR04 is a small, easy-to-use Perl wrapper for reading distance measurements from an HC-SR04 ultrasonic sensor on a Raspberry Pi. It requires the wiringPi library and exposes a simple object interface where you give the GPIO pins for TRIG and ECHO and then call inch, cm or raw to get a distance reading. The module does not manage timing for you, so you should pause a few milliseconds between repeated reads to avoid erratic results. Be sure to protect the Pi by reducing the HC-SR04 ECHO output to the Pi's 3.3V GPIO level with a resistor divider or regulator. Recent maintenance fixed an undefined behavior in the XS setup routine by switching to setenv to avoid corrupting the environment and aligned the test gate name to RPI_BOARD.

RPi::GPIOExpander::MCP23017 is a lightweight Perl interface for the MCP23017 I2C GPIO expander that gives you access to 16 digital pins arranged as two 8‑pin banks. It provides simple, high level methods to set pins as inputs or outputs, read pin states, drive outputs, enable the chip's internal pull‑ups, and operate on single pins, entire banks, or all pins at once, plus a cleanup method to restore the chip to its startup state and optional low level register access for advanced use. The module covers the core functionality you need to extend GPIO capacity from Perl, is aimed at Raspberry Pi workflows but works with any accessible I2C bus, and notes that some features such as interrupt support are not yet implemented but planned for future releases.

RPi::DigiPot::MCP4XXXX is a compact Perl module that lets a Raspberry Pi control Microchip MCP41xxx and MCP42xxx digital potentiometers over the SPI bus. It wraps wiringPi's SPI calls to send the 16-bit control and data words the chips expect and exposes simple methods to set a pot tap value from 0 to 255 and to put the device into shutdown. The MCP41 series provides a single potentiometer and the MCP42 series provides two, and the module lets you address either one or both. You instantiate it with the GPIO pin used for chip select and the SPI channel and then call set or shutdown as needed. The module requires wiringPi (via WiringPi::API) and now uses RPi::Const for hardware constants, with recent releases migrating constants to RPi::Const and updating WiringPi prereqs.

RPi::DHT11 is a lightweight Perl module for reading temperature and humidity from a DHT11 sensor connected to a Raspberry Pi GPIO pin. It relies on the WiringPi library and uses BCM pin numbering by default while also honoring an existing RPi::WiringPi object's pin scheme if that object is created first. You create the object with the sensor DATA pin number and then call temp (pass 'f' to get Fahrenheit) and humidity to receive integer readings, and the module provides cleanup behavior automatically on destroy with an optional debug flag for extra output. There are environment variable switches to help run or test code off a real Pi. This module is a good fit when you want a simple, direct way to poll a DHT11 from Perl on a Raspberry Pi.