CPANscan

CallBackery is a Mojolicious-based framework for quickly building appliance-style web frontends that pair a Perl backend with a Qooxdoo JavaScript client. It provides ready-to-use wiring for configuration (default etc/callbackery.cfg or overridden via CALLBACKERY_CONF), a pluggable database object, RPC service namespace and controller, and application-wide security headers, and exposes a startup hook that mounts the Mojolicious app and routes. Use it when you want to deliver a rich single-page management UI driven by Perl without building the plumbing yourself. Note: a recent release switched the RPC layer to JSON-RPC 2.0, so you must use Qooxdoo 7.x and the matching Mojolicious::Plugin::Qooxdoo update and upgrade frontend and backend together.

Chemistry::OpenSMILES is a Perl toolkit for reading and writing SMILES chemical identifiers that follows the OpenSMILES v1.0 specification and is aimed at developers who need to convert SMILES strings into manipulable molecular graphs or produce SMILES from graph data. Its parser turns SMILES into Graph::Undirected objects where each atom is a Perl hash with fields for element, isotope, charge, hydrogen count, chirality and position, and its writer converts those graphs back to SMILES with a range of options to control hydrogen, aromatic and parentheses output. The module handles disconnected moieties, ring and cis/trans stereo, a variety of chiral types, valence calculations and aromaticity checks, and recent releases added explicit ring-detection utilities including rings() and can_be_aromatic_ring() to improve aromaticity handling. If you need a configurable, OpenSMILES-compliant SMILES reader/writer in Perl for cheminformatics tasks, this module provides a ready-to-use, well-evolved implementation.

Template::Sluz is a minimal Perl templating engine with a Smarty-like syntax that makes it easy to separate presentation from code in small to medium Perl projects. You instantiate it, assign scalars, arrays or hashes, and render templates from files with fetch or from strings with parse_string. The template language supports variable interpolation, chained modifiers and default values, if/elseif/else conditionals, foreach loops, include files, literal blocks and comments. A convenient feature is that any Perl built-in or user function can be used as a modifier so templates can call functions like ucfirst, join or substr with the template variable passed as the first argument. Its simple API and lightweight design suit cases where you want straightforward templating without a heavy framework.

CPAN::MetaPackager is a small utility for building and managing a local SQLite mirror of the CPAN package index, cpan.metapackager.sqlite, by converting the canonical CPAN package-list file (02packages.details.txt.gz) into a searchable SQL database. It is useful if you need a local, machine-friendly copy of CPAN metadata for offline querying, custom tooling, packaging workflows, or fast lookups without hitting the network for every query. The module is maintained by Ron Savage under the Perl 5 license and is production-ready at version 1.00 and above. Recent releases make it easier to keep the database current by downloading the latest 02packages.details.txt.gz and rebuilding the DB automatically, and include clearer instructions and timing information during import to help you monitor updates.

CPAN::MetaCurator is a toolkit for building, inspecting and exporting a local SQLite database of CPAN metadata derived from Perl.Wiki and related sources, with utilities to turn that data into a jsTree-style HTML site map and other reports. It bundles modules and command-line scripts to import 02packages.details.txt or CPAN::MetaPackager databases, gather and validate module and topic statistics, search for module names, and produce web-ready exports with clickable nodes and hover text. The project is aimed at maintainers who want to curate, rebuild or publish a browsable Perl module catalogue and includes validation and parsing helpers to keep the tree accurate. The latest release rebuilt the database and rewrote the usage instructions in MetaCurator.pm to simplify rebuilding and exporting workflows.

Test::MockModule lets you temporarily override subroutines in other Perl packages so you can stub or fake behavior during unit tests. It records the original routines and restores them automatically when the mock objects go out of scope or when you call unmock, which makes cleanup simple and reliable. You can use mock to replace functions with code refs or scalars, redefine to assert the function already exists, define to assert it does not, and original or original_for to call the real implementation from inside a mock. The module also offers convenience helpers such as noop to install harmless methods that return true and mock_all to catch unexpected calls, and it supports lexical strict and global-strict modes to avoid masking interface changes. It integrates with Moose and Mouse metaobjects so mocked methods participate in MOP checks but does not special-case Moo or Role::Tiny and will warn if the target class is immutable. If you need to fake exported functions, remember to mock them in the importing package or use fully qualified names to get the effect you expect.

Git::Server is a drop-in replacement for a standard Git server that adds powerful, server-side control features so teams can run secure, policy-driven repositories without adopting a heavy platform. It gives fine-grained ACLs and hooks so you can restrict who can push, who can rewrite history, which files can be changed, and even whitelist IPs or author emails, while providing tools like a git-client wrapper and git-deploy to automate pushes and deployments. The module also supports flexible webhook callbacks, proxying/sync to external remotes, access logging and rotation, and a variety of deployment and compatibility fixes for older Git and non-Linux systems. Recent updates focus on reliability and operational load, running webhooks serially and retrying failed callbacks, plus improvements to the client/deploy shims and proxy sync behavior. The project is actively maintained on GitHub and is intended to be an easy replacement for ssh-based Git hosting when you need stronger hooks and access control.

Map::Metro::Plugin::Map::Berlin is a small plugin for the Map::Metro Perl toolkit that provides a ready-made model of Berlin's transit network. It returns a parsed graph of stations and links encompassing both the U-Bahn and S-Bahn so you can perform route finding, visualization, or scripting without assembling the network data yourself. Use it via Map::Metro->new('Berlin')->parse or the map-metro.pl command line and it integrates with the rest of the Map::Metro ecosystem.

Map::Tube::Berlin is a lightweight Perl module that gives you a programmatic way to query Berlin's S‑ and U‑Bahn network. You create a Map::Tube::Berlin object and call get_shortest_route with a start and end station name to get back the sequence of stations along the shortest path. Station names are case insensitive and the map includes both U‑ and S‑Bahn stops. The route data comes from an XML file generated from BBBike project data and a Makefile rule is provided to rebuild the map if you have a local BBBike copy.

Business::GoCardless is the top-level Perl library for talking to the GoCardless payments API, providing a collection of modules that let your app create and manage resources like payments, payouts, mandates, redirect flows and merchants while handling lower-level concerns such as webhooks, signature checking, nonce management and parameter normalization. You normally start with Business::GoCardless::Pro rather than using this module directly. The distribution aims to mirror the GoCardless API so you can work with bills, payouts, payments and related objects, and it includes conveniences and bug fixes around JSON encoding, legacy webhook handling and API compatibility. It does not implement partner account handling yet. The recent 0.45 release adds richer Mandate support including a mandate_type attribute, helper methods for common mandate kinds, new attributes for authorisation_source and next possible ACH charge date, and additional mandate status checks such as consumed, blocked and suspended_by_payer.

File::Symlink::Relative is a small Perl module that makes it easy to create relative symbolic links by converting a given source path into a path relative to the link location and then calling Perl's symlink built-in. It exports a symlink_r function by default and provides a SYMLINK_SUPPORTED constant so you can detect whether the current platform supports symlinks. The module will still install on systems without symlink support but will throw an exception when you attempt to create a link. Use it when you want a simple, tested helper to produce relative symlinks without writing your own path manipulation code.

Encode::RAD50 is a small Perl Encode module that converts strings to and from the vintage RAD50 character set used on PDP-11 systems such as RSX‑11, RT‑11 and RSTS. It implements Encode-compatible encode and decode operations and a PerlIO encoding layer so you can pack and unpack RAD50 data streams, where three limited characters (uppercase letters, digits, space, period and dollar) are squeezed into two bytes and invalid characters are represented by a substitution marker. The module pads inputs that are not a multiple of three with trailing spaces and will emit warnings about invalid input unless you explicitly silence them for testing, and because RAD50 is nonstandard you must explicitly load Encode::RAD50 before use. The test suite has been exercised across multiple platforms and the author maintains support via GitHub, and the most recent release (0.019) updated bug tracker and contact metadata and repackaged license files without changing functionality.

Date::ManipX::Almanac extends the Date::Manip family with almanac-style date and time operations so you can ask about events like sunrise, full moon, or when a planet sets. It currently implements date-level features through Date::ManipX::Almanac::Date and serves as the top-level module in the almanac hierarchy while remaining a subclass of Date::Manip so code can test for DM5 or DM6 compatibility via isa. Recent releases were maintenance-focused, improving licensing and GitHub packaging, adding a SECURITY policy and CI workflows, and updating contact information without changing functionality. If you need astronomical event times integrated with Date::Manip, this module is relevant and issues can be reported on the project's GitHub page.

Lingua::famibeib is the top-level Perl interface for working with famibeib, an artificial language, providing a simple entry point into the family of modules that handle parsing and manipulation. It delegates concrete tasks to companion modules like Lingua::famibeib::Text for text handling and parsing, Lingua::famibeib::Sentence for sentence-level actions, and Lingua::famibeib::Word for word-level operations, and it inherits behavior from Data::Identifier::Interface::Known. Use this module if you need to parse, analyze, or generate famibeib content from Perl code and want a convenient hub that connects to the higher-level components you will actually use.

Test::MixedScripts helps you catch potentially malicious or confusing Unicode in source and text files by checking that the characters used belong only to an expected set of Unicode scripts. It provides file_scripts_ok to validate a specific file and all_perl_files_scripts_ok to scan the Perl files in a distribution, defaulting to Common and Latin but allowing overrides per file, per line with a special comment, or for larger sections via a POD directive. The module reports the unexpected script together with the character name and the exact file, line and character position to make fixes straightforward. It can also be asked to enforce strict ASCII and will skip or warn when asked to test scripts not supported by your Perl build. This requires Perl 5.16 or later and does not try to detect confusable characters that come from the same script. The project is maintained on GitHub and recent releases added ASCII testing and a number of documentation and test-suite improvements.

SPVM::Sys is a comprehensive, cross-platform system interface for SPVM that exposes POSIX-style operations for file I/O, directories and stat, sockets, time, process control, signals, environment variables and user/group queries, with many convenience methods that mirror Perl idioms like the -X file tests. It wraps low level calls such as open/read/write, sysopen/sysread/syswrite, socket/connect/accept, fork/exec/wait and utime while providing supporting classes for socket addresses, timeval/timespec, directory and file streams and more. Windows Unicode is handled automatically by converting between SPVM strings and UTF-16 filenames so you can use the same APIs on Windows and Unix, and the distribution includes utilities such as globbing, portable TCP keepalive configuration and environment manipulation. Recent updates added MSVC build support, improved Sys#glob for UTF-8 and Windows Unicode case folding, and enhanced set_tcp_keepalive with an optional interval parameter while fixing several Windows and memory bugs, so this is a good fit if you need low-level, portable system primitives from SPVM code.

Minion::Backend::mysql is a MySQL storage backend for the Minion job queue that plugs into Mojolicious apps and uses Mojo::mysql to persist jobs, schedules and worker state. It creates the necessary tables automatically via migrations and provides the full Minion API for enqueuing, dequeuing, retries, priorities, dependencies, scheduled jobs, worker registration and job metadata, so you can manage background tasks with familiar Minion primitives. The backend includes a prefetch cache to improve throughput when jobs are short and lets you tune cache size and expiry. It requires MySQL 5.6.5 or later and may need extra privileges when installing on MySQL 8 if binary logging is enabled, which can block the database migrations. If you use Minion with MySQL and Mojolicious this module is the ready-made connector to store and dispatch your background work.

Net::HTTP2::nghttp2 is a Perl XS wrapper around the mature nghttp2 C library that brings full HTTP/2 support to Perl programs, letting you build both clients and servers that use streams, header compression, server push, and flow-controlled streaming bodies. It exposes a session-based API with callbacks for headers, data, and stream events so you can handle requests and responses incrementally and implement features like large uploads, streaming downloads, and WebSocket bootstrapping over HTTP/2 (RFC 8441). The module requires the nghttp2 library to be installed and offers an available method to check that linkage, and users can simplify installation via Alien::nghttp2. It has been conformance tested against h2spec with a high pass rate and documents a few intentional, lenient behaviors inherited from nghttp2 that improve interoperability rather than strict RFC enforcement. If you need production-ready HTTP/2 primitives in Perl and are comfortable wiring socket or TLS I/O into a callback loop, this module gives you a direct, low-level bridge to a widely used C implementation.

Alien::nghttp2 provides a simple way for Perl modules to use the nghttp2 HTTP/2 C library by detecting a system install or downloading and building the library for you. It exposes standard Alien::Base methods to return compiler flags, linker flags, dynamic library paths and the install type so you can easily populate Makefile.PL or Alien::Build arguments when building XS code or other native extensions. nghttp2 is a production-grade HTTP/2 and HPACK implementation used by projects like curl and Firefox, so this module is handy whenever a Perl distribution needs to link against an established HTTP/2 client library. Use Alien::nghttp2 to avoid manual dependency management and to make builds more portable across systems.

Email::Abuse::Investigator inspects raw RFC‑2822 email source to help abuse investigators and security analysts quickly find the message origin, the hosts and domains mentioned, and the appropriate parties to report. It walks the Received header chain to pick the first external hop and enriches that IP with reverse DNS and RDAP/WHOIS data, extracts HTTP/HTTPS URLs from plain and HTML parts and maps their hosts to network owners, and collects contact domains from headers and body to run a domain intelligence pipeline that gathers A/MX/NS records and registrar WHOIS details. The module produces a detailed analyst report, a compact abuse report body suitable for sending to abuse desks, a risk assessment with weighted flags, plus email and web-form contacts to notify, and it can reuse cached lookups across messages when CHI is available for faster bulk processing. Optional modules such as Net::DNS, LWP::UserAgent, AnyEvent::DNS, IO::Socket::IP, and Domain::PublicSuffix enhance DNS, RDAP/WHOIS, parallel resolution, IPv6 WHOIS, and domain normalisation. Recent 0.10 changes add a public header_value() accessor, add per-message caching for abuse_contacts(), and refactor the risk assessment into clearer private checks while expanding tests and robustness. Known limitations documented by the author include no charset conversion for body text, a hand-rolled MIME parser that is not fully RFC compliant, IPv4-only CIDR matching for trusted_relays, no retry handling for WHOIS rate limits, lack of live DMARC DNS lookups, and the class is not thread-safe.

URI is a general purpose Perl class for creating, parsing and manipulating Uniform Resource Identifiers according to the RFCs, letting you build absolute or relative URIs, combine them with base URIs, and convert them to and from plain strings or Unicode IRIs. It exposes simple accessors to get and set components like scheme, authority, host, port, path, query and fragment, plus convenience helpers to canonicalize and compare URIs, turn relative URIs into absolute ones and vice versa, and work with query data using form- and keyword-oriented methods. The module dispatches to scheme-specific subclasses when available so you get extra methods for common schemes such as http, https, ftp, file, mailto, ldap, ws and many others, and it knows about default ports, IDNA host handling and percent-encoding rules. It is stable and widely used but the author notes a couple of quirks to watch for such as odd behavior when passing regexp variables like $1 directly to accessors and the way non-ASCII bytes are percent-encoded depending on a string s internal UTF8 flag. If you need a robust, RFC-aware URI toolkit in Perl for building, normalizing or dissecting URIs this module is a solid choice.

Lemonldap::Portal::Standard is a Perl module that implements the authentication workflow for the Lemonldap single sign on system and provides a ready-made LDAP-backed form login handler. It drives the whole login cycle from request and timeout handling to form validation, optional user ID formatting, LDAP connect/bind/search, session construction and final credential validation, and each step can be overridden with custom callbacks. You instantiate it with new and call process with CGI-like parameters and LDAP settings, and it supports anonymous binds by leaving the manager credentials undefined. Helper methods return error codes and messages, session data and redirection URLs and the module uses a specific nonfatal code for an initial empty form so you can distinguish that case. The component is GPLv2 licensed and is useful when you need an extensible, production-ready LDAP authentication layer for a web SSO setup.

Finance::Bank::Bankwest is a Perl library for programmatically logging into Bankwest Online Banking with a Personal Access Number and access code so you can list accounts, read balances and fetch transaction histories via a returned Session object. It exposes account and transaction objects with useful helpers so scripts can report balances and iterate transactions easily. This is an unofficial third‑party client so you should audit the code and check Bankwest’s terms before using it in production because Bankwest does not support this module. The project is maintained on GitHub and recent updates improved robustness by skipping post‑login service‑message pages automatically and by tolerating missing transaction codes in some responses. The module is free software licensed under the same terms as Perl.

Crypt::DSA is a pure-Perl implementation of the Digital Signature Algorithm that provides key generation, signing and signature verification with the heavy numeric work delegated to Math::Pari. You create a Crypt::DSA object, generate a keypair (you must pick the p size, with q and g fixed at 160 bits), sign either a message or an explicit 20-byte digest (the module will SHA1 the message for you) and verify signatures using the public key; the API is intentionally similar to Crypt::RSA and returns Crypt::DSA::Key and Crypt::DSA::Signature objects. Important security notes: DSA is no longer recommended for new systems and this module is marked deprecated in favor of alternatives such as Crypt-DSA-GMP, so use it only to verify legacy signatures. Recent releases fixed critical issues including a nonce reuse flaw (CVE-2026-12205) that could allow private-key recovery if the same key was used to sign multiple messages with affected versions, so any keys used to sign more than once with those versions should be considered compromised.

Apertur::SDK is the official Perl client for the Apertur API that simplifies common tasks like creating upload sessions, uploading images (including optional encrypted uploads), long polling for processing results, verifying webhook signatures, and performing CRUD on destinations, API keys, webhooks and encryption keys. It supports both API key and OAuth token authentication and will auto-select the sandbox environment when given a test key prefix, so you can develop safely. Errors are thrown as typed exception objects to make handling authentication, validation and rate limit problems straightforward. Encryption features are provided but require optional crypto modules which are loaded only when needed. If you build Perl applications that interact with Apertur for image ingestion or delivery workflows this SDK gives a convenient, ready-made interface.

Jacode is a compact Perl library for detecting and converting Japanese text between common encodings such as JIS, EUC, Shift_JIS and UTF-8, with support for newer JIS X 0213 planes and utilities to inspect escape sequences and encoding boundaries. It exposes simple routines like convert to transcode a scalar in place, getcode to guess the encoding of a buffer, and helpers to examine JIS in/out escape states, and on modern Perls it can act as a wrapper around Encode when asked to handle other encodings. The module is written to be broadly compatible with older Perl releases while staying usable on current Perls and includes extensive tests and documentation. A recent maintenance update simplified the UTF-8 source-file self-check so it no longer uses Perl‑5‑only syntax and added a small safeguard to suppress a spurious apostrophe-package-separator warning on very new Perls, improving backward and forward compatibility.

Config::IniFiles is a mature Perl utility for reading, editing and writing human-friendly INI-style configuration files. It gives both an object API and a tied-hash interface so you can fetch and set values by section and parameter, handle multi-line values and here-doc style blocks, preserve and manage comments and trailing comments, use default or fallback sections, toggle case sensitivity, and import or overlay one configuration on top of another with optional delta-only writes for compact site-specific files. The module accepts filenames, filehandles or scalar refs and includes helpers to add, copy, rename or delete sections and to write the configuration back to disk. Recent maintenance includes a security fix addressing CVE-2026-11527 in version 3.001000. Be aware that WriteConfig may not preserve original comment placement perfectly and does not perform file locking, so applications that write concurrently should take care.

Data::Identifier provides a single, format‑independent object for working with many kinds of identifiers such as UUIDs, OIDs, URIs, Wikidata and FactGrid IDs, GTIN, IBAN, BIC, DOI and others, letting you keep both the raw value and its type while offering normalization and basic deduplication. It can create identifiers from strings or from other objects, produce canonical forms (UUID, OID, URI or a combined ISE form), generate high quality random identifiers from a variety of sources, compare and sort identifiers, and convert them into related objects for use with URI and tagging libraries or file and datecode modules. The module supports type-level options like validation patterns, namespaces and generators, returns user-friendly display names or permanent tagnames for UI use, and lets you register frequently used identifiers to improve performance. Validation and deduplication aim for practicality and speed so they may not catch every invalid value and deduplication is not guaranteed to merge all equal identifiers. Some features are marked experimental and you can disable OID support to gain speed if you do not need it.

Mac::Pasteboard provides a Perl interface to macOS pasteboards and the system clipboard, letting scripts and programs read and write clipboard data. It offers simple exported helpers pbpaste and pbcopy for plain text and a full object-oriented API to work with named pasteboards, individual pasteboard items and Uniform Type Identifier flavors so you can store or retrieve different data types and inspect flavor flags and tags. The module includes optional encoding handling for several text UTIs, taint-aware behavior, error/status reporting and a set of constants for common pasteboard errors and flags. Note that it requires macOS 10.3 or later, currently only accesses the first item on multi-item pasteboards, does not support promised data, and some encoding behavior may be unreliable on older macOS or Perl versions. If you need programmatic clipboard control on macOS from Perl, this module supplies a practical and featureful toolkit.

HTML::TableContentParser is a small utility for pulling the contents of HTML tables into simple Perl data structures so you can work with rows, cells and headers without writing a full DOM scraper. You create a parser and call parse($html) to get an array reference of tables found in document order, and each table is returned as a hashref containing attributes plus useful keys like caption, headers and rows where each row lists its cells and any th/header entries with their text in a data field. There is a classic option to preserve older behavior for <th> handling if you need backward compatibility. The module intentionally ignores rowspan and colspan and nested tables are reported separately rather than being linked into their parent cell, but recent maintenance releases fixed nested-table truncation and improved row-header (<th>) support along with metadata and test updates.