CPANscan

LaTeX::ToUnicode is a small utility that turns common LaTeX markup such as accent commands, special characters and a few simple formatting commands into literal Unicode characters or into numeric HTML/XML entities, making it useful for converting fragments like bibliography entries and abstracts for display on the web or in plain text. It is designed for simplicity rather than complete fidelity so it removes braces, collapses extra whitespace and leaves complex structures such as math, tables, figures and most macros alone so you can spot untranslated commands by remaining backslashes. The convert function accepts options to emit entities instead of binary Unicode, to enable German-package shorthand, to produce minimal HTML output for links and basic emphasis, and to call a user hook for custom substitutions; a supplied regexp for terminating control words helps write safe hooks. This module is not a full document converter and does not attempt to be exhaustive, but it is practical for the common cases encountered when extracting text from LaTeX sources. Recent updates have broadened the set of recognized control sequences and improved handling of some cases, for example recognizing guillemet commands and converting \allowbreak to a zero-width space to produce cleaner output.

BibTeX::Parser is a pure Perl module for reading and parsing BibTeX bibliographies. It provides a streaming serial mode that yields entries one at a time for very large files and a caching mode that loads all entries for random access, counting and key-based lookup. Parsed entries expose their type and field values and offer canonicalized author and editor objects to simplify name handling. The constructor takes a filehandle and options such as an errorlevel setting to control how parse errors are reported. Use next to iterate through entries or read plus entry, entrykeys and has to work with the cached collection, making this module useful for Perl scripts that need to consume, transform or analyze BibTeX data.

RPi::RTC::DS3231 is an XS-based Perl interface for talking to a DS3231 real-time clock chip over I2C, packaged for Raspberry Pi but usable on any Linux system with I2C support. It provides simple methods to read and write individual date and time fields or set the whole timestamp as a "YYYY-MM-DD HH:MM:SS" string, switch between 12/24 hour modes and AM/PM, return an "HH:MM:SS" string, read the module's temperature in Celsius or Fahrenheit, and produce a DateTime-ready hash for easy construction of DateTime objects. The module should also work with DS1307 devices though that is untested, and you should close the device when finished. Recent fixes corrected BCD encoding bugs that could corrupt month and hour writes and normalized temperature output to two decimal places, so date/time and temperature reads behave reliably.

Music::VoicePhrase is a small Perl helper for algorithmic composition that builds measured phrases of multiple voices with both pitch and rhythm. It combines scale and interval selection from Music::Scales and Music::VoiceGen with rhythmic partitions from Music::Duration::Partition so you can generate motifs and matching voices for a measure-length phrase using simple attributes like base note, scale, octave, measure size, duration pool and motif count. The object exposes handy real-time attributes such as a priority queue, an index, current note and onsets so it can be used in live or streaming contexts. If you need to programmatically create short melodic phrases or drive MIDI/playback scripts, this module gives a lightweight, configurable building block for that work. Recent updates added the real-time-friendly attributes and voice handling to make live use easier.

BsDiPa is a Perl wrapper around Colin Percival's BSDiff code that makes it easy to create and apply compact binary patches from memory. It exposes simple core_diff_* and core_patch_* functions for producing and applying diffs and supports multiple compression backends when available, including zlib, bzip2, xz and zstd, plus a raw (uncompressed) mode for testing. The module always uses the integrated libdivsufsort optimization and operates in a 31-bit size mode, and it also offers a special text-oriented differential mode by passing a negative magic_window value. You can control compression behavior and resource use with per-operation I/O cookies or some global settings, and compile-time constants (HAVE_BZ2, HAVE_XZ, HAVE_ZSTD) tell you which compressors are available. Returns are uniform and include status constants like OK, FBIG, NOMEM and INVAL. If you need to build efficient binary-updates, delta distribution or patch-based synchronization inside Perl code, BsDiPa provides a compact, well-tested interface to BSDiff with multiple compression choices.

MetaCPAN::Client is a Perl library that gives you a convenient, DWIM-capable interface to the MetaCPAN web API so you can look up authors, distributions, releases, modules, files, CVEs and other CPAN metadata and get back rich Perl objects or iterable result sets. You can do simple lookups by name or PAUSE id or run complex boolean searches via a hash-based search spec using either/all/not to express OR/AND/NOT queries and you can fetch large result sets efficiently with the built-in scroller. The module also supports helper endpoints like autocomplete, recent releases, POD retrieval in multiple formats, and download_url queries with version ranges, and it lets you plug in a custom user agent or add caching for long running processes or scripts. It aims to be lightweight while exposing the full MetaCPAN API, so it is useful for command line tools, web apps and daemons that need up-to-date CPAN data. Recent maintenance fixes include ResultSet items now returning an arrayref and various Elasticsearch and CVE indexing improvements to keep the client compatible with the evolving MetaCPAN API.

CPAN::Audit is a Perl library for checking installed CPAN modules against the CPAN Security Advisory database so you can find known vulnerabilities that affect your code or servers. It is the engine behind the cpan-audit command line tool and links advisory reports to distributions and the specific versions you have installed, making it easy to see whether an installed module is affected. The advisory data now lives in a separate CPANSA::DB distribution so updates can be delivered independently, and CPAN::Audit will try to load CPANSA::DB and fall back to the older CPAN::Audit::DB with a deprecation warning; support for the old DB is being phased out. Recent fixes include resolving a warning when a module version could not be found and clarifications to how installed-version checks are performed. If you manage Perl installations or worry about supply-chain security, this module provides a straightforward way to automate vulnerability checks against CPAN advisories.

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.