CPANscan

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.

OrePAN2::S3 is a utility for running a private DarkPAN-style CPAN mirror on Amazon S3 with optional CloudFront CDN support. It provides a command-line script and modulino for adding and removing tarball distributions, rebuilding a browsable index page from your manifest, uploading extra assets, and creating simple HTML docs from README or POD. The mirror is configured with a JSON file that can hold multiple profiles and lets you customize S3 prefixes, templates for index.html, extra files to upload, and CloudFront invalidation paths so your site stays up to date. If you host or distribute Perl modules internally or want an easy, static, secure way to publish a curated CPAN-like repository, this tool automates the common tasks. Recent updates in 1.2.3 improve the upload-artifacts feature and add support for a distribution directory so artifact uploads can come from package contents or fully qualified paths.

RPi::DAC::MCP4922 is a lightweight Perl driver for Raspberry Pi projects that need to control Microchip MCP49x2 family digital-to-analog converters over SPI. It exposes a simple object interface to the dual‑channel MCP4902, MCP4912 and MCP4922 devices so you can set analog outputs by value, enable or disable each channel in software, and optionally control the chip shutdown pin via a GPIO for hardware shutdown. The module handles the different resolutions of the chips (8, 10 and 12 bit) and the usual SPI and chip‑select details for you, so it is useful whenever you want to generate analog voltages from a Pi. Recent maintenance migrated constant definitions to RPi::Const and bumped WiringPi::API prerequisites to keep compatibility with updated Raspberry Pi wiring libraries.

RPi::BMP180 is a small, easy-to-use Perl driver for the BMP180 barometric pressure and temperature sensor on a Raspberry Pi. You create a sensor object by giving it a pin base number to reserve pseudo GPIO pins and then call temp to get a temperature reading or pressure to get the barometric pressure in kilopascals, with both methods returning floating point values. Note that temp returns Fahrenheit by default and accepts 'c' to return Celsius. The module is intentionally lightweight and is a good fit when you just need straightforward access to BMP180 readings from Perl on a Raspberry Pi. Recent updates modernize dependency handling and bump required versions of WiringPi::API and RPi::Const so it works with current WiringPi stacks.

RPi::ADC::MCP3008 is a small Perl module that lets a Raspberry Pi read analog voltages from an MCP3008 10-bit, 8-channel ADC over SPI, returning raw 0–1023 values or percent readings. It relies on WiringPi and the C pthread library and can use the hardware SPI chip-select pins CE0 or CE1 or bit-bang SPI using any other GPIO pin so you can free the hardware CS lines. The API is minimal and easy to use: create the object with the SPI channel or GPIO pin to use for chip select and call raw() or percent() for single-ended or differential channel reads. The author notes the code should also work with MCP3002 and MCP3004 though those were not formally tested. Recent updates migrated constants to RPi::Const and updated the WiringPi setup calls to wiringPiSetupGpio and wiringPiSPISetup to remain compatible with WiringPi::API 3.18.

RPi::Pin is a small, object-oriented interface for controlling Raspberry Pi GPIO pins that lets you set pin mode, read and write digital states, configure internal pull resistors, use hardware PWM and arm edge-triggered interrupts while using the BCM pin numbering scheme. It is the per-pin companion to RPi::WiringPi and can be used directly for simple scripts though RPi::WiringPi provides extra safety and cleanup. You can switch a pin between input, output, PWM or alternate functions, attach human-readable comments to pins, and use mode_alt for special hardware functions. Interrupt handling has grown richer recently and now requires a CODE reference for callbacks, supports an optional debounce window and optional auto-dispatch, and offers background_interrupt to run handlers in a forked child so they fire even while your main program is busy. Note that hardware PWM is only available on the appropriate GPIO pin (GPIO18) and recent releases enforce that pwm() must be run as root.

Web::Microformats2 is a Perl toolkit for extracting Microformats2 metadata from HTML or from already-serialized MF2 JSON and presenting it as a queryable in-memory document made of item objects representing things like posts, people, and events. It includes a parser that reads the special class-based MF2 annotations in ordinary web pages and builds Document and Item objects you can interrogate for properties such as name, date, author, rels, and nested items, and you can serialize and rehydrate those structures as MF2 JSON. The implementation aims to be feature-complete and passes the official MF2 baseline tests, and the author describes the API as beta while maintaining backwards-minded compatibility. The recent 0.512 release is noteworthy because the parser no longer dies on malformed or legacy URLs, it stopped leaking HTML::TreeBuilder global state so it no longer affects other code in the same process, and it now chooses the best available JSON backend for better performance. If you need to pull structured semantic metadata out of web pages for indexing, aggregation, or syndication, this module is directly relevant.

CLI::Simple is a lightweight, object-oriented helper for building Perl command-line tools that need options, subcommands and simple lifecycle hooks. It parses Getopt::Long-style options, auto-generates getter/setter accessors, wires in Log::Log4perl for logging, and dispatches command methods with a clean init/run flow. The module is built around the modulino pattern so a single module can be both a reusable library and an executable script, and version 2 adds an optional role-based workflow driven by a YAML manifest and Role::Tiny so larger apps can declare commands in a spec and scaffold role stubs automatically. It also supplies useful utilities like bash completion generation, built-in internal commands for introspection and migration, aliasing for commands and options, and a low dependency footprint, making it a good fit for internal tools and admin scripts that want structure without a heavy framework. Per-command log levels are supported when you define commands programmatically but are not yet expressible in the YAML manifest, and validation is intentionally left to the application so you can keep control of behavior.

RPi::SPI is a simple Perl interface for talking to devices on the SPI bus from a Raspberry Pi or any Unix-like system with SPI support. It opens a hardware SPI channel (CE0 or CE1) or, if you pass a channel number above 1, treats that number as a GPIO pin and automatically bit-bangs the chip select line so you can attach extra SPI slaves. You create an object with new(channel, speed) where speed defaults to 1 MHz, and use rw(buffer, length) to write bytes and receive the simultaneous response back as a Perl array. The module will die if it cannot open the SPI device, and it is suited for controlling sensors, ADCs, displays and other SPI peripherals from Perl scripts.

RPi::I2C provides a straightforward Perl interface to communicate with I2C devices, primarily on Raspberry Pi systems but usable on any Unix box with the standard I2C libraries installed. You create an object for a device address (defaults to /dev/i2c-1) and can read and write single bytes, 16-bit words, or blocks of bytes, plus a convenience process method that writes then reads 16 bits, and helpers to check device presence and surface IO errors. The module includes examples for Arduino integration and is used as part of the RPi::WiringPi test suite, though its own unit tests are minimal. Before use you must enable I2C on the Pi and install system packages such as libi2c-dev and i2c-tools, and you may need to lower the Pi I2C baud rate when talking to slower devices like Arduinos.

Win32::Mechanize::NotepadPlusPlus is a Perl module for automating the Windows text editor Notepad++ from outside the app. It gives you a Notepad object for controlling the application and Editor objects for manipulating the internal Scintilla editor panes, with simple helpers like notepad(), editor(), editor1() and editor2() to drive common tasks such as opening, editing, saving, and closing files or scripting UI actions. The module can attach to an existing Notepad++ instance or launch one when it finds the executable in a standard location or on your PATH, but you must have Notepad++ installed and use the same 32 or 64 bit as your Perl. Note that callback hooks into Scintilla or Notepad++ are not yet implemented, the author tested primarily with US English and UTF-8/ANSI encodings, and Windows is the intended platform. Install from CPAN.

DBIx::OnlineDDL is a Perl utility for making schema changes on large live tables with minimal disruption by creating a new table, applying DDL while the table is empty, copying rows in controlled batches, and swapping the tables when ready. It is designed to work with DBIx::BatchChunker for safe row copying and with DBIx::Connector::Retry or DBIx::Class for robust connection handling, and it maintains foreign keys and triggers more faithfully than many other online schema change tools. The module gives you hooks for running your DDL on the empty copy and for running any large DML before the swap, wraps the whole process in an undo stack for safe rollbacks, and aims for cross-RDBMS compatibility using DBI info and ANSI SQL; it currently supports MySQL and SQLite. You should still prefer built-in online DDL where available or skip this approach for very small, fast changes or pure DML tasks. Recent changes in v1.1.2 include preserving a trigger's original sql_mode when re-creating triggers and smarter logic for ID truncation during ID searches.

Matplotlib::Simple is a Perl helper that turns Perl data structures into ready-to-run Python3 matplotlib scripts so you can produce charts without learning matplotlib itself. You feed it hashes or arrays describing your data and options and it writes a Python file (by default into /tmp) that can be edited or executed to produce output images, with built-in support for single plots and multi-panel figures. It covers most common plot types such as bar, grouped or stacked bars, boxplot, hist, hist2d, hexbin, imshow, pie, plot, scatter, violin, and colored tables, and it maps many familiar axis and styling options directly to matplotlib equivalents including colorbars, log scales, error bars, and figure sizing. The module is aimed at Perl developers who want quick, high-level plotting via matplotlib while keeping the option to inspect or tweak the generated Python, and it requires a working Python3 and matplotlib installation.

Zuzu is a small Perl helper for running ZuzuScript code from Perl, offering zuzu_eval to parse and execute a script string and zuzu_evalfile to load and run a UTF-8 script file, with both returning the evaluation result. You can pass runtime options to control the execution environment, for example to restrict modules or add library paths, which makes the module handy for embedding Zuzu scripting in Perl programs, running quick one-off scripts, or building tooling around Zuzu. See the Zuzu language site for full language and runtime details. Zuzu is free software released under the Artistic License 1.0 or the GNU GPL version 2.

ICANN::RST is a Perl module for working with ICANN's Registry System Testing (RST) machine-readable test specifications, making it easy to load test plans, enumerate cases, and produce human-friendly outputs such as the published HTML test spec. It is aimed at registry operators, registry service providers, and test automation tools that need to validate readiness for TLD delegation, provider transitions, or new registry services. The typical workflow is to instantiate ICANN::RST::Spec, ask for a named plan like StandardPreDelegationTest, and then iterate its cases and resources, so you can build reports or drive automated test runners. Recent changes include a new 0.03 API that replaces the older versions() call with new_from_version for loading a specific released spec; an earlier 0.02 update added support for querying releases via the GitHub API.

Tstregex is a lightweight Perl module and command line utility that helps you quickly diagnose why a regular expression did not match by showing the longest substring that did match and highlighting the exact part that failed. You can run it as a CLI tool to get an annotated string and a pointer to the failing token, or embed it via a simple API that prepares a regex context, runs the diagnostic, and returns whether the input fully matched plus the failing token and match length. The tool uses a "nibbling" strategy to search progressively smaller valid subpatterns so it can pinpoint the precise regex atom or quantifier that caused the break and report execution time to help spot exponential backtracking or ReDoS risk. It is aimed at developers who want a quick, automated way to troubleshoot complex Perl patterns without dropping into a full debugger. Recent releases stabilized the module for CPAN/MetaCPAN indexing, improved Windows compatibility, and formalized the production 1.00 release while adding ReDoS detection and cross-platform fixes.

MARC::Convert::Wikidata converts MARC bibliographic records into Wikibase::Datatype item objects suitable for loading into Wikidata, with a focus on handling real-world library data and many Czech National Library specific cases. You feed it a MARC::Record and it detects the item type (monograph, audiobook, or periodical), extracts identifiers and metadata, and builds a Wikibase::Datatype::Item while letting you plug in callbacks for covers, language mapping, people resolution, publishers and series lookups. The module bundles numerous cleanup and parsing heuristics for messy fields like edition numbers, series ordinals, publication places, page counts and dates so it is especially useful when converting legacy or national-library MARC data into structured Wikidata statements. Key methods include new, wikidata, type, object and look_for_external_id and it relies on MARC::Record and Wikibase::Datatype among other helpers. Recent work in 0.34 added handling for series ordinals, improved conversion of roman numerals to arabic, changed the audiobook instance mapping, and made author-name processing more robust when no QID is available. If you need a pragmatic, callback-driven bridge from MARC to Wikidata and your source resembles Czech national library records this module will save a lot of manual mapping work.

Parse::Syslog::Line is a compact Perl utility that parses a single syslog line into a convenient hash reference containing parsed fields like priority and facility, host and domain, program name and PID, the original and cleaned message, structured data, and multiple timestamp formats including epoch and an ISO‑8601 UTC time. It can auto-detect and decode JSON or Splunk-style key/value pairs, extract RFC5424 structured data, and offers a multiline-aware parse_syslog_lines helper for streamed input. The module exposes simple toggles to control expensive program extraction, date parsing behavior, timezone handling, and pruning of raw or empty fields so you can trade accuracy for speed when needed. Date parsing uses Time::Moment for performance and portability, and the author warns that local timezone strings around daylight saving transitions may be unreliable so prefer epoch or datetime_utc for portability. Recent maintenance releases removed the DateTime dependency and tightened timestamp testing to UTC, improving packaging and test robustness.

Perl::Critic::Policy::RegularExpressions::ProhibitEmptyAlternatives is a static linting rule for Perl that flags empty alternatives in regular expressions, such as /a||b/, because those alternatives always succeed and are usually accidental. By default it forbids empty alternatives anywhere, treats empty entries in bracketed character classes as outright violations, and can be tuned to allow an empty final alternative or to ignore empties inside right-anchored groups via configuration options. This makes it a handy safety check for developers who want to avoid subtle, always-true regex branches that can mask bugs. Support and issue tracking are handled by the author on GitHub, and the most recent release updated packaging and metadata, added SECURITY and CONTRIBUTING documents, and made no functional changes.