CPANscan

Markdown::Simple is a fast XS-based Perl module for converting Markdown to HTML that defaults to GitHub Flavored Markdown but can be switched to strict CommonMark and tuned by turning individual features on or off. It provides a simple functional interface for one-off conversions and an object-oriented renderer that reuses the parser's internal arena to avoid repeated allocations when converting many documents. There is also a strip_markdown utility that removes markup while keeping text scan-readable. The implementation is performance-oriented, with SIMD acceleration on supported CPUs and recent fixes for platform and build issues including OpenBSD load failures and C89 compatibility, so it is a good choice when you want a configurable, high-performance Markdown-to-HTML converter in Perl.

Amazon::Signature4::Lite is a compact Perl module that generates AWS Signature Version 4 headers for signing S3 and other AWS API requests, returning a hashref of headers ready to merge into HTTP::Tiny requests. You instantiate it with your access key, secret key, region and optional session token for temporary credentials, and it will produce Authorization, x-amz-date, x-amz-content-sha256, host and x-amz-security-token headers as needed. The module is designed to be dependency-light and not rely on LWP or HTTP::Request, so it fits well in small scripts and constrained environments. It also provides a helper to extract service and region from AWS endpoint hostnames, but that parser is focused on S3/AWS patterns rather than general URL parsing.

Object::Proto is a lightweight, high-performance Perl object framework that stores objects as compact arrays and maps property names to slot indices at compile time so accessors and constructors run very fast. It produces properly blessed objects so isa, can and ordinary package methods work as expected and it supports positional or named constructors, built-in and custom type checks, and rich per-slot modifiers like required, readonly, default, lazy/builder, weak and triggers. The system includes single and multiple inheritance, prototype chains, roles, method modifiers, BUILD/DEMOLISH hooks, cloning, locking and freezing, plus introspection helpers for slots and ancestry, and it can import function-style accessors compiled to custom ops for even better performance. An XS API lets C extensions register cheap, C-level type checks and recent releases improved downstream XS linking and fixed packaging and documentation issues. Use Object::Proto when you want a compact, low‑overhead object layer tuned for speed and C interoperability while retaining familiar Perl OO behaviour.

Net::PayPal::Lite is an unofficial, lightweight Perl client for PayPal's REST API that lets you charge credit cards, store cards in PayPal's vault, look up payments and make arbitrary API calls via a generic rest method. It requires a PayPal client_id and secret and defaults to the sandbox environment so you can develop safely before switching to live mode. To avoid requesting a fresh OAuth token on every call it caches access tokens and provides hooks to choose where and how the cache is stored or transformed, while explicitly avoiding persisting client secrets or enabling encryption by default. The module is a fork of Net::PayPal and is not affiliated with PayPal. Recent updates focused on documentation fixes and clarified that keys are not stored and that CBC encryption is not enabled out of the box so you control how credentials and tokens are handled.

List::SomeUtils::XS provides a compiled C (XS) backend for the List::SomeUtils Perl module, giving the same list utility functions but implemented in native code for better performance. It is not user-facing and you normally do not install it directly; when List::SomeUtils is installed and a compiler is available, the installer will pull in this module so you get the faster implementation automatically. The distribution intentionally omits an explicit metadata dependency on List::SomeUtils to avoid a circular dependency, so this module cannot function on its own. Source and bug reports are maintained on GitHub and the code is released under the Artistic License 2.0.

Net::Google::Analytics::MeasurementProtocol is a lightweight Perl client for sending event data directly to Google Analytics 4 using the Measurement Protocol, letting you report server-side or offline user interactions alongside your browser-based analytics. You construct it with your GA4 API Secret and Measurement ID and then call send to post a single event or send_multiple to batch events in one HTTP request, with a configurable HTTP agent (it defaults to Furl). The module includes a debug mode that posts to Google’s validation endpoint so you can see why a payload might be rejected, and it documents practical tips such as supplying a real client_id and including session_id and engagement_time_msec for events to surface in standard GA4 reports. It targets GA4 only and will not work with older Universal Analytics APIs, and the author notes two current limitations: it cannot send User Properties and it does not validate input for you. The package was recently updated to stay compliant with GA4.

Text::CSV_XS is a fast, XS-backed Perl library for reliably parsing and generating comma separated values, offering both a low-level object API and a convenient csv() function for one-liners and scripts. It handles input from files, filehandles or in-memory strings and writes to files or scalars, supports custom separators, quote and escape characters, and provides robust features for real-world data such as binary mode for embedded newlines and nulls, Unicode and BOM handling, header-aware parsing into arrays of hashes, streaming with callbacks and filters, and convenient utilities like fragment selection and bind_columns for high-performance loops. The module also exposes detailed diagnostics and configurable safety options like strict parsing, formula handling and empty field semantics, and it can be combined with other modules to dump databases or convert CSV to JSON or Excel formats. Be aware that it does not attempt to auto-detect separator or quote characters for you and that exchanging CSV with applications like Excel can be tricky due to locale and format differences, but for most CSV tasks Text::CSV_XS is the go-to choice in Perl for speed, flexibility and robust error handling.

SVG::Timeline is a small Perl utility for generating SVG timeline charts from simple event data, letting you programmatically build a row of year markers and a stack of labeled bars that represent start and end dates. You create an object, add events with a text label plus a start and end expressed as a year or a full date (YYYY-MM-DD), optionally set colors and layout options like width, height and years-per-grid, and then call draw to produce SVG output suitable for web or print. The module handles date parsing with DateTime so it works with older dates, supports sensible defaults for sizing and colors, and is designed to be easy to subclass if you need custom drawing behavior. A recent release fixed label overflow to the right so long event labels no longer run past the chart edge.

DBD::CSV is a DBI driver that lets you treat plain CSV files as a simple SQL database from Perl, so you can use familiar DBI methods to SELECT, INSERT, UPDATE and DELETE rows without running a separate database server. It relies on Text::CSV_XS for robust CSV parsing and SQL::Statement for SQL execution, and you can configure directory, file names, field separators, quoting, encoding and per-table options to match exports from Excel, Access or other tools. The driver supports typical SQL features provided by SQL::Statement including joins and functions, and integrates with DBI error handling and parameter binding. Note that CREATE TABLE only stores column names, not types or constraints, NULL handling requires the csv_null option, and file locking depends on flock so concurrency protection may be limited on some platforms. If you need a lightweight way to query and manipulate CSV data from Perl with DBI-style SQL, DBD::CSV is a convenient and configurable solution.

DBI is the de facto database abstraction layer for Perl that gives your scripts a consistent, driver-independent way to connect to and talk with many different databases. It defines a small, well thought out API for connecting, preparing statements, binding parameters, executing queries, fetching rows and managing transactions so you can write code that is portable across any DBD::* driver. DBI encourages safe practices by supporting placeholders to avoid SQL injection and by offering helpers like quote, selectrow_*, selectall_*, and cached connect/prepare helpers for common patterns. It also includes utilities for tracing, profiling and callbacks to help you debug, tune, and customize behaviour. Remember that DBI itself is an interface layer so database-specific behaviour, supported features and performance come from the underlying DBD driver, and some newer DBI features may not be implemented by every driver.

Dancer2::Plugin::Auth::OAuth is a plugin for the Dancer2 web framework that lets you add OAuth-based login to your Perl app with configuration only. It automatically creates authentication routes (by default under /auth/<provider> and /auth/<provider>/callback), performs the OAuth handshake, and saves provider tokens and user information in the session under the "oauth" key so your app can use id_tokens or access tokens to call provider APIs. Several common providers are supported out of the box, including Facebook, Google, Twitter, GitHub, LinkedIn and StackExchange, and you can customize scopes, query parameters and redirect URLs in YAML. The plugin also provides an automatic /auth/<provider>/refresh route to renew tokens without forcing a full re-login and offers options for how to handle refresh failures. Recent releases improved security by generating an OAuth state parameter to mitigate CSRF and by producing nonces from a secure source of randomness.

Sisimai is a Perl library for parsing and decoding bounce and delivery-status emails into structured data so you can reliably extract who bounced, why, and when. It accepts mailbox files, Maildir directories, raw message strings or STDIN and returns rich Perl objects or JSON that include sender and recipient addresses, delivery status and reply codes, bounce reason, timestamp and other metadata including the original file path. The API is simple: rise() returns decoded objects, dump() returns JSON, and helper methods let you list supported engines, known reasons, match freeform error text to a reason, and check the module version. Sisimai supports callbacks to collect extra headers or run per-message processing, and it exposes options to include delivered messages or handle vacation auto-replies which are excluded by default from v5.0.0 onward. It is a practical tool for mail system operators and developers who need to automate bounce handling, generate reports or feed bounce data into downstream systems, and it is maintained under a BSD license with project resources on GitHub.

App::CdUtils is a small collection of command line helpers that make navigating the filesystem from your shell easier. It provides backend programs such as cdtree-backend, cdtarget-backend, cdsibling-backend, cdnextsibling-backend, cdprevsibling-backend and cdpart-backend that are meant to be wired into shell scripts or cd wrappers so you can jump to parent path parts, find directory targets, move to sibling directories or step to the next or previous sibling without typing long paths. The tools are lightweight, intended for integration with custom shell tooling, and the distribution is available on CPAN with source hosted on GitHub.

SPVM::Sys is a comprehensive, cross-platform system-call wrapper that exposes low-level OS services to SPVM programs, including file and directory operations, buffered and unbuffered I/O, sockets and networking, time and timer utilities, process control and signals, and user/group lookups. It packages familiar primitives like open/sysopen, read/write, stat/lstat, mkdir/rmdir, socket/connect/listen/accept, select/ioctl, fork/exec, wait/waitpid, env manipulation, and many POSIX-style file tests into a single, consistent API and provides helper classes for streams, dir handles, socket addresses, time structs, constants, and errno handling. The module emphasizes portability and Windows Unicode support by automatically converting between UTF-8 and wide strings and includes many platform-specific fixes and fallbacks so the same code works on Linux, macOS, and Windows. If you need system-level control from SPVM or are porting Perl-style system code to SPVM, SPVM::Sys gives you a ready-made, tested interface; recent releases notably improved Windows support by adding waitpid on Windows, a nonblocking spawnvp_nowait helper, and updated networking helpers that use inet_pton for address handling.

Algorithm::Classifier::IsolationForest provides an easy-to-use implementation of Isolation Forest and Extended Isolation Forest for unsupervised anomaly detection on numerical datasets. It builds an ensemble of random isolation trees and scores points by their average isolation depth so that outliers are isolated quickly and receive high scores near 1 while normal points score well below 0.5. You can choose classic axis-aligned splits or extended oblique hyperplane splits to reduce axis bias, and tune ensemble size, sample size, tree depth, random seed, and an optional contamination parameter so the model can learn a threshold for flagging anomalies. The module exposes fit, score_samples, predict and path_lengths helpers and supports JSON save/load for model persistence and reproducible results, making it a practical choice for detecting outliers in exploratory data analysis, monitoring, and preprocessing pipelines.

Net::IMAP::Client is a Perl library that gives you a simple, scriptable API for talking to IMAP servers while doing rigorous parsing of server responses so you get useful Perl data structures rather than raw text. It supports plain or TLS/SSL connections, UID mode, SEARCH and SORT, fast multi‑folder STATUS queries, folder listing and management, fetching message summaries (parsed into Net::IMAP::Client::MsgSummary objects), downloading full RFC822 bodies or individual MIME parts as scalar references for efficiency, flag management, copy/append/expunge operations, threading and server notifications. The module returns undef on failure and exposes last_error for diagnostics, and it deliberately returns message data undecoded so you can decode attachments or transfer encodings with Email::MIME::Encodings or similar. Note that only cleartext login is supported out of the box and the author lists stronger authentication schemes as a TODO item. Recent maintenance updated the IMAP atom parsing to better match RFC3501 and fix a parsing bug, making the client more robust with a wider range of servers.

App::karr is the core library behind karr, a Git-native kanban tool that keeps tasks as Markdown payloads and board configuration as sparse YAML stored in Git refs under refs/karr, so your repository remains the single source of truth without introducing a persistent board tree or file-level merge conflicts. It powers the karr CLI, which materializes a temporary board view for each command and then writes changes back into refs, and it exposes lower-level modules for programmatic access when you need to automate or inspect board state from Perl. The project includes a first-class Docker runtime for easy embedding in other environments and supports common workflows like creating, listing, claiming, and snapshotting tasks from the command line or from scripts. If you want a lightweight, Git-centric way to track work where history and synchronization are handled by Git itself, this module and its CLI are a good fit. Recent releases improved the karr-foundation runner to stream agent output to the terminal, made the foundation a multi-board coordinator, introduced role-qualified activity logs to separate human and agent actions, and added usability enhancements to commands such as show and board while surfacing clearer Git errors during sync.

Module::Extract::VERSION is a small utility for safely pulling the $VERSION out of a Perl module source file without running the module itself, so it is useful for packaging, indexing, or automation tools that need to know a module version. You give it a file and it finds the single $VERSION line, extracts and evaluates the value in a Safe compartment, and returns either the version string or, in list context, extra details such as the sigil, fully qualified variable name, version value, file name and line number. It assumes there is only one $VERSION declaration in the file and that the declaration is all on one line, and recent updates add compatibility for older qv() syntax from version.pm so more version formats are recognized.

Syntax::Infix::EqualityInsensitive adds two lexically scoped infix operators, eqi and nei, so you can write case-insensitive string comparisons that use proper Unicode case folding rather than ASCII lowercasing. Use if ($input eqi 'yes') to match YES, Yes, yes, and odd Unicode cases like the German sharp-s with correct behavior. The operators live at relational precedence alongside eq and ne, are non-associative, and compile down to custom BINOPs via Infix::Custom for efficient runtime behavior. They only affect the file or block that uses the module and can be undone with no Syntax::Infix::EqualityInsensitive. Note that the module requires Perl 5.38 or newer.

Identifier::PL::PESEL is a compact Perl module for validating Polish PESEL national identification numbers. It provides a simple object interface: instantiate with new and call validate($number) to receive 1 for a valid PESEL or undef for an invalid one, and validate will Carp::confess if you omit the argument. The module is intentionally lightweight and focused on format and checksum checking, making it a good choice when you need a minimal, dependency-free way to verify Polish IDs. The 0.3 release only updates package metadata.

Finance::Quote is a Perl toolkit for fetching stock, mutual fund and bond quotes from a wide range of internet sources and exchanges, exposing a simple object API where you create a quoter, call fetch with one or more methods and symbols, and receive a hash keyed by symbol and label (price, bid, volume, date, currency and many other fields). It bundles many exchange‑specific modules, supports configurable timeouts, optional failover between providers, and on‑the‑fly currency conversion via pluggable CurrencyRates modules (some require API keys), and it includes handy utilities for parsing dates, CSVs and scaled numeric values. The module is actively maintained to adapt scrapers and add API sources, most recently adding a Finnhub backend for API-based quotes and updating Google Finance parsing while introducing additional currency rate providers. You can install it from CPAN, it respects your HTTP proxy settings, and a small anonymous usage counter is enabled by default but can be disabled with the FQ_NOCOUNT environment variable.

Amazon::API is a lightweight, generic Perl base class for invoking AWS services that you can use directly for ad hoc requests or as the parent for service-specific modules generated from Botocore metadata with the included amazon-api tool. It handles credential discovery and signing, negotiates content types, decodes JSON or XML responses, supports pagination, and provides helpers for formatting complex AWS request shapes so you can build small, focused clients without pulling in a full SDK. If you use it raw you should be familiar with the target AWS API because some services have protocol quirks, and the author notes S3 is better served by dedicated modules or Paws for broad coverage. The project is mature and production ready for many services and recent 2.2.x updates improved Botocore-based serialization and fixed several payload edge cases including rest-xml and map/list serialization and an uninitialized payload error.

CPANSA::DB provides the CPAN Security Advisory dataset as a ready-to-use Perl data structure. It exposes a single method, db, which returns a hashref of all advisory reports so you can programmatically inspect, audit, or integrate CPAN security information. The module is primarily consumed by CPAN::Audit but can be used by any tool that needs the advisories. Each release includes a GPG signature and a GitHub attestation so you can verify the archive came from the official repository, and a JSON export of the same data is available if you prefer non-Perl formats. If you need a simple, verifiable source of CPAN security advisories for auditing, monitoring, or tooling, this module provides that in a minimal, dependable package.

Business::ISBN::Data is a data-only companion to Business::ISBN that supplies the official ISBN registration-group and publisher-range information used to parse, validate, and split ISBNs. You normally do not load it directly because Business::ISBN will load it for you, and the module ships with a copy of the ISBN Agency's RangeMessage.xml so you get authoritative ranges out of the box. If you need newer or alternate data you can point Business::ISBN at another RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading the module, and if no file is available it falls back to built-in data or looks in the current directory to help bundled apps. Note that it requires Business::ISBN 3.005 or later to match the updated data structures addressing ISBN-13 handling. The project is actively updated with frequent data refreshes through June 2026, includes a recent fix to avoid unintended autovivification when reading ISBN_RANGE_MESSAGE, and is maintained on GitHub under the Artistic License 2.0.

Time::Str is a compact, standards-focused toolkit for parsing and formatting date/time strings into Unix epoch values or precise component hashes, handling ISO 8601 and many internet and legacy formats such as RFC3339, RFC2822, HTTP, ASN.1, SQL, ECMAScript, Common Log Format and more, plus a permissive "DateTime" parser for real-world variants. Its API centers on str2time to produce numeric timestamps (including fractional seconds), str2date to return validated components with nanosecond precision preserved, and time2str to render timestamps with configurable precision or exact nanosecond output and either fixed offsets or DST-aware timezone objects. Time zone abbreviations are captured but not resolved automatically unless you provide a timezone_map or a timezone object, and the module interoperates cleanly with DateTime, Time::Moment and Time::HiRes. It ships with both a Pure-Perl implementation and an optional C/XS backend for speed, and the latest release adds a native Ragel-based C parser for the DateTime format that yields roughly a 20x performance improvement over the regexp parser. The module documents strict validation and precision behavior and exposes helpful constants, while noting some limitations such as English-only month and weekday names, no ISO week or ordinal-date support, and a supported year range of 0001–9999.

Mail::DMARC is a mature Perl toolkit that implements the DMARC email authentication and reporting standard so mail servers, spam filters, and senders can check whether incoming messages are legitimately aligned with a domain's policy and generate or consume DMARC reports. You give it basic envelope and header metadata plus SPF and DKIM results and it evaluates policy conformance, returns a structured Result object, and can persist aggregate reports to a configurable SQL-backed store tested with SQLite, MySQL and PostgreSQL. The distribution includes a PurePerl engine and an optional libopendmarc XS backend, command line and web utilities for viewing, sending and receiving reports, and flexible report storage and delivery mechanisms over SMTP or HTTP. Recent releases add support for newer DMARC-related RFCs including RFC 9989 and RFC 9990 with agreement reporting, improved handling of messages with multiple From addresses, and better IDN conversion, making it a practical choice for operators who need full DMARC validation and reporting in Perl.

CPAN::FindDependencies lets you discover the dependency tree for any CPAN module by consulting the CPAN package index and fetching distribution metadata or Makefile.PL files from a mirror, then returning a list of Dependency objects that include each module's name, distribution, required version and depth in the tree. It supports options to limit depth, add recommended or suggested modules, cache fetched metadata, specify one or more mirrors or an alternate perl core version, and choose whether missing Makefile.PL files should be executed to infer dynamic deps. The module prunes duplicates and automatically omits modules that are already in the specified perl core, so the output is focused and easy to reconstruct into a tree. You must have network access to CPAN or a local cache and startup can be slow when the index is fetched, and dynamic or platform‑specific requirements cannot always be resolved reliably. Be aware that enabling the Makefile.PL feature downloads and may run remote code so it should only be used when you accept that security risk.

Catalyst::Plugin::OpenIDConnect turns a Catalyst web app into an OpenID Connect provider by adding the standard OIDC endpoints, JWT handling, state and code storage, and a reusable controller you extend in your app. It is not an OIDC client and is intended for applications that issue ID and access tokens to relying parties; configuration covers issuer metadata, RSA keys, and client registrations including redirect URIs and allowed scopes. The plugin mounts discovery, authorize, token, userinfo, JWKS and logout endpoints under a configurable namespace and can use either an in-memory store or a Redis backend for multi-process deployments, with built‑in PKCE, refresh token rotation, and many hardening fixes to address common security issues. Recent releases added extension points for custom user claims and scope handlers and fixed JWT signature compatibility with OpenSSL 3, making it easier to integrate with external JWT libraries and to extend claim behavior for specialized deployments. If you need to implement an authorization server inside a Catalyst application and want a tested, security-focused OIDC implementation you can configure and extend, this plugin is a strong fit.

This module is a Perl client for the Aspose.Cells Cloud service that lets Perl programs work with spreadsheets in the cloud rather than handling files locally. It gives you a central configuration object for API credentials and endpoints and a simple factory-style helper to create API clients, so you can authenticate, call the REST endpoints and perform tasks like creating, reading, converting and manipulating Excel workbooks from Perl code. The package is aimed at developers who want to integrate cloud-based spreadsheet processing into Perl applications without implementing the HTTP and authentication plumbing themselves.

App::plockf is a tiny CPAN placeholder package that makes the plockf utility available; plockf runs another command while holding a file lock so you can serialize access to a resource or prevent multiple instances of a script or cron job from running concurrently. The App::plockf distribution itself is just a CPAN packaging wrapper and does not add new functionality beyond exposing plockf, which is a compact, well maintained tool with only minor fixes over time and a recent test fix for Windows.