CPANscan

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.

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.