CPANscan

Text::Names::Abbreviate is a small Perl utility for producing concise, configurable abbreviations of personal names. It accepts names in "First Middle Last" or "Last, First Middle" forms and can emit styles such as "J. Q. Adams", "G.R.R.M.", "JQA", or "Adams, J. Q." using options for format, name order, and the separator appended to initials. The module NFC-normalizes Unicode input and can optionally absorb surname particles like "van" or "de" into the last name. The API is stateless and returns a plain string given a name and an options hashref. It does not detect or strip honorifics or suffixes, particle matching is case sensitive, and the compact and initials formats are lossy so re-abbreviating them will not reproduce the original. This is a handy choice when you need predictable, configurable short forms of personal names for display or text processing.

Stats::LikeR brings a broad, R-flavored toolkit of statistics and data-frame utilities to Perl, offering fast XS-backed implementations of common numeric reducers, hypothesis tests, modeling and reshaping tools and table I/O so you can do R-like analysis without leaving Perl. It understands multiple data shapes (array-of-hashes, hash-of-arrays, hash-of-hashes and array-of-arrays) and provides convenient operations such as read_table/write_table, add_data/assign, reshape helpers (aoh2hoa, hoa2aoh, aoh2hoh, hoh2hoa), summary and view, binning and quantiles, correlation and covariance, many tests (t, wilcox, kruskal, chi-sq, Fisher, KS), linear and generalized linear models with predict, PCA and more. The API returns plain Perl hashrefs and arrayrefs so results are easy to consume, it tries to follow R semantics where useful and it handles missing data and common edge cases explicitly. The module emphasizes speed and practical usability, but documents a few limitations such as Type I (sequential) ANOVA behavior and some factor-level handling in predict that require manual preprocessing when re-expanding categorical variables. If you want a comprehensive, R-like stats toolbox implemented for Perl with attention to performance and familiar data-frame idioms, this module is very relevant.

Time::Nanos gives Perl programs simple, high-resolution time functions by wrapping clock_gettime, providing nanos, micros and millis to return the current time as integer nanoseconds, microseconds or milliseconds, or if called with a true argument to return a (seconds, subunits) pair for easier elapsed-time calculations. By default it uses the system clock (realtime) but you can switch to a monotonic clock to avoid system clock adjustments using Time::Nanos::clock_source('monotonic') since clock_source is not exported. On 32-bit Perl builds nanosecond precision is coarser (roughly 256 ns) and realtime reads can occasionally appear to go backwards when the system clock is changed. Recent changes add the seconds-plus-units return option, a $CLOCK variable for external clock selection, Windows high-resolution timer support and a stopwatch example.

Data::RoaringBitmap::Shared provides a compact, process-shared set of 32-bit unsigned integers using the Roaring bitmap idea so you can efficiently store and query large sparse or dense integer sets across processes on Linux. You create an anonymous, file-backed, or memfd-backed bitmap and then add, remove, test membership, get cardinality, min, max, or export all values, and perform in-place union or intersection with another shared bitmap while concurrent mutations are serialized by robust futex locks with dead-process recovery. Capacity is fixed at creation as a pool of 8 KiB container slots so you should size it for the number of high-16 groups your data uses, and note v1 supports only array and bitmap containers, does not down-convert bitmaps to arrays, and offers union/intersect but not xor or andnot. The module requires Linux and 64-bit Perl and supports safe sharing via fork, backing files, or passing memfd descriptors between processes. The recent release tightened security by creating backing files with mode 0600 by default so data is owner-only unless you explicitly request wider permissions.

Data::RingBuffer::Shared provides a simple fixed-size circular buffer placed in shared memory so multiple Linux processes can publish and read recent values without blocking or coordination. Writers always succeed and overwrite the oldest entry when full while readers can fetch the latest value, the Nth-latest, or read by absolute sequence number, and you can also dump the whole ring or wait for new data with a timeout. The module ships typed variants for 64-bit integers and doubles and exposes constructors that attach to files or memfd, returns a sequence number for each write, and offers eventfd hooks for notification. It requires 64-bit Perl and Linux only, and its backing files default to owner-only permissions for safety though you can pass a file mode to share across users. Recent updates tightened security by creating backing files with mode 0600 by default and improved robustness around abandoned writer recovery and large capacities.

Data::RadixTree::Shared provides a compact, compressed radix tree (a PATRICIA-style trie) that stores byte-string keys mapped to 64-bit unsigned integer values in a shared memory mapping on Linux. It excels at exact lookup and longest-prefix queries, so it is well suited to routing tables, dispatch tables and autocomplete backends where you need the most specific stored prefix that matches a query. Multiple processes can share one tree via a backing file, an inherited anonymous mapping after fork, or a transferable memfd, and reads run in parallel under a reader lock while inserts and deletes are serialized by a futex-based write-preferring lock with dead-process recovery. Keys must be raw bytes and wide characters will cause an error, values are unsigned integers, and the structure uses edge compression so operations are proportional to key length rather than tree size. Capacity is fixed at creation for both node count and label arena size so you must size the mapping for your working set, and deletes in this v1 release are lazy and do not reclaim space until you call clear. This module requires Linux and 64-bit Perl and exposes familiar methods for insert, lookup, longest_prefix, delete, clear, stats and lifecycle management of the backing store.

Data::Queue::Shared provides fast, bounded multi-producer multi-consumer queues that live in shared memory so multiple processes on the same Linux box can push and pop items with very low overhead. It offers separate variants tuned for fixed-size integers and for variable-length byte strings, with the integer queues using a lock-free algorithm for maximum throughput and the string queue using a futex-protected circular arena to store messages efficiently. You can back a queue with a filesystem file, an anonymous mapping inherited by fork, or a memfd that you pass between processes, and the API supports nonblocking and blocking operations with timeouts, batch push/pop, peeking, and optional eventfd notifications for integrating with event loops. The module includes crash-recovery for the string mutex, diagnostic stats, and secure defaults for backing-file permissions, and benchmarks show large performance gains over many traditional IPC methods for typical producer/consumer workloads. Note that the string queue serializes pushes under heavy multi-producer contention and the module requires Linux and 64-bit Perl, so pick the integer or deque variants if you need lock-free scaling for fixed-size payloads.

Data::Pool::Shared is a Linux-only, 64-bit-Perl module that gives you a fixed-size, lock-free object pool in shared memory so multiple processes can allocate, use, and return numbered slots much like a cross-process heap. It comes in a raw byte variant and typed flavors for int64, int32, double, and fixed-length strings, and provides atomic operations on numeric slots, blocking alloc with futex wakeups when the pool is full, batch alloc/free for efficiency, zero-copy read-only scalars that map directly into the shared memory, raw pointers for FFI or OpenGL, memfd and anonymous mappings, and guard objects that auto-free slots at scope exit. The pool tracks allocator PIDs and offers recover_stale to reclaim slots held by dead processes, and recent releases hardened security by creating backing files mode 0600 by default and by rejecting attempts to attach with mismatched capacity or element size. Use this module when you need fast, concurrent, cross-process storage or counters and you can target Linux with 64-bit Perl.

Data::Stack::Shared is a Linux-only Perl module that implements a high-performance shared-memory LIFO stack for multi-process use, with variants for 64-bit integers and fixed-length strings and options for anonymous, memfd or file-backed mappings. It supports safe multi-producer/multi-consumer push and pop operations, non-blocking and blocking calls with optional timeouts, a peek operation, eventfd-based notifications, and runtime stats and control such as capacity and a concurrency-safe drain. The module is designed for throughput and low latency and exposes file-backed persistence with sensible default permissions; note that it requires 64-bit Perl and the on-disk format was bumped to version 2 so older v1 files created by earlier releases will not open. The drain operation includes a recovery mechanism that reclaims slots stuck in a publishing state to avoid permanent wedging, but that recovery can silently discard a legitimately long-stalled publisher’s value if it exceeds the timeout threshold.

File::Stubb is the small command-line wrapper for stubb, the stub file creator, that parses @ARGV and exposes simple init and run methods so you can initialize stubb with command-line options and execute template rendering from Perl code. It is a private helper module rather than end-user documentation, so consult the stubb manual for usage details, but in practice File::Stubb handles argument parsing and dispatch so the stubb executable behaves predictably. Recent updates make template handling more robust by changing non-target markers to backslashes, tightening validation of targets, allowing rendering to standard output in more cases, and fixing file handle leaks, so command-line rendering is safer and more reliable. The project is hosted on Codeberg under the GPL and welcomes issues and contributions.

Dancer2::Plugin::OIDC is a Dancer2 plugin that makes it easy to add OpenID Connect authentication and OAuth2 access token validation to your web app without implementing an identity provider. It wraps the OIDC::Client library and provides a simple oidc() helper, automatic callback routes, and session-aware helpers so your application can act as a Relying Party and optionally validate tokens as a Resource Server. The plugin supports multiple providers with configurable client settings, common flows like redirect-to-authorize, token verification, role and scope checks, and building API useragents that propagate security context. The author recommends keeping session and token data on the backend for security, and recent releases update compatibility with OIDC::Client v1.08 including PKCE-related adjustments and test updates.

Jacode is a compact Perl module for detecting and converting Japanese text between common encodings such as JIS, EUC, Shift_JIS and UTF-8, offering easy-to-call routines like convert() to transcode a buffer and getcode() to guess an input encoding. It includes utilities for handling JIS escape sequences and can act as a compatibility wrapper to Encode::from_to on newer Perls, making it useful for scripts that must interoperate with legacy Japanese data and older Perl installations. The module is maintained with attention to compatibility and correctness and requires Perl 5.00503 or later. A recent fix ensures the AUTOLOAD wrapper preserves list versus scalar context, so functions that return multiple values such as getcode() and convert() now behave correctly in both list and scalar forms.

Music::VoicePhrase is a lightweight generator for measured musical phrases that pairs rhythmic motifs with pitched voices so you can produce playable MIDI phrases for algorithmic composition or live performance. It combines scale and octave settings with a duration partitioner and a voice generator to produce lists of motifs and voices, and exposes convenient attributes such as base, scale, size, pool, weights, motif_num, patch and channel so you can shape pitch, rhythm and MIDI output. The module includes realtime-friendly state like a priority queue, index, current note, onsets and a gate parameter for controlling note length during rt-midi playback, and provides simple methods to rebuild motifs and voices or advance the playback index. If you need a small, configurable tool to create measured musical phrases programmatically or to drive MIDI synthesis in realtime, Music::VoicePhrase gives you the building blocks with sensible defaults and easy customization; recent updates improved the documentation and added the gate attribute for rt-midi use.

Net::Blossom::Server::Backend::Postgres is a Postgres-backed storage implementation for Net::Blossom::Server that keeps blob bytes and metadata inside PostgreSQL via DBI and DBD::Pg. It stores blob bodies in bytea columns so uploads and deletes can be transactional, provides a deploy_schema helper to create the necessary tables, and implements the storage contract with methods to begin uploads, commit and read blobs, fetch descriptors without bodies, delete blobs or individual owners, and list a user's descriptors with cursored pagination. You can construct it from a DSN or an existing Postgres DBI handle and supply a normalized base_url for public descriptor links. The backend serializes uploads and deletes for the same hash with PostgreSQL advisory locks while allowing concurrent operations for different hashes, but direct SQL modifications to the tables do not participate in that locking protocol. Very large public media services may still prefer to store blob bytes outside the metadata database.

Geo::Coder::List is a glue module that lets you combine many geocoding providers behind a single, simple interface so you can route queries to specific services, apply per-provider query limits, and fail over until one returns a usable result. It always keeps a fast in-memory L1 cache and can use an optional L2 cache via CHI or a plain hash, and it normalizes each provider's quirky output into a consistent structure with canonical latitude and longitude fields that work with HTML::GoogleMaps::V3 and HTML::OSM. You build a chain of geocoders with push, run geocode or reverse_geocode calls and get the first successful result (or all candidates from the winning backend in list context), set a shared LWP user agent across backends, and inspect a built-in request log which you can flush. The constructor supports cloning and environment-driven configuration via Object::Configure. Note the module currently does not accept Geo::Location::Point objects for reverse geocoding and when Geo::GeoNames returns nested candidate arrays only the first element of each subarray is used.

Map::Tube::Plugin::Graph is a small Moo role that plugs into the Map::Tube family to turn tube maps into graph objects and rendered images. It provides as_graph to yield a multiedged Graph object you can analyze or hand to GraphViz2 for custom visualisation, and as_png and as_image to produce PNG files or base64 encoded images of either the entire map or a single named line. Use it when you want to do graph‑theory work on transit networks, filter or style individual lines, or generate programmatic map images from Map::Tube data. The plugin depends on the GraphViz2 toolchain, so you will need GraphViz2 installed and recent Perl (GraphViz2 v2.61 requires perl 5.8.8 or newer) to render images.

Map::Tube::CLI is a simple command-line front end for Map::Tube maps that provides quick route queries and map generation from the terminal. It installs the map-tube script and lets you ask for shortest or preferred routes between stations, display results as a compact list or a formatted table, list available maps, lines and stations, and generate PNG images of entire maps or single lines. The tool ships with many city maps but can also use locally installed maps via a --force option. It also supports generating line mappings and line notes for deeper inspection. The module exposes a single run() entry point used by the script and is aimed at developers, sysadmins and transit enthusiasts who want a lightweight, scriptable way to query and render Map::Tube data. In the v1.0.0 release the --line_mappings output was corrected to restrict connections to the requested line and the dependency was updated to Map::Tube v5.1.0.

Map::Tube is a lightweight Perl framework for modeling transit networks and finding routes between stations, implemented as a Moo role that loads map data in JSON or XML and exposes simple methods to query stations, lines and nodes and to compute routes. Its routing prefers the fewest stops and breaks ties by minimizing line changes using a small fractional penalty, and it returns rich Route, Node and Line objects for programmatic use. The module can also list all possible routes between two points although that feature is marked experimental and can recurse deeply on very large maps. A plugin system adds useful extras such as PNG image generation of maps, output formatting to JSON/XML/YAML/string and fuzzy name lookup for stations and lines. Map::Tube includes tools and test helpers for validating map data and ships with many city maps, so it is a good fit if you need to build route-finding utilities, visualizations or simple transit APIs in Perl.

oEdtk::Main is the central module of the oEdtk toolkit designed to help batch-process structured, fixed-width text records for industrial printing and document assembly. It provides a simple procedural API to open a job, read input lines, recognize records by a key, unpack fields using declared templates, run user hooks before and after processing, and format output records for a downstream document builder, with extracted values exposed in a global data array for easy access. The module is most useful when you need to convert or reformat legacy record files into compuset or database-ready output and want an event hook model for custom transformations. The distribution also includes tooling for tracking and logging and database administration; recent 1.5xxx updates improved config file lookup order, strengthened DBAdmin CSV import and tracking fields, and added options to route warnings and errors into the tracking database. This module is presented primarily as a documented toolkit with example usage and is a good fit if you work with fixed-record file workflows in printing or document management.

Geo::Coder::Free is a Perl geocoding toolkit that lets you translate addresses to latitude/longitude using local copies of free datasets rather than paid web APIs, by building a single SQLite (or optionally Redis/MariaDB-backed) database from sources like OpenAddresses, Who'sOnFirst, MaxMind, GeoNames and OpenStreetMap. It provides a simple programmatic API and a command-line mode plus example CGI code for running a local geocoding service, and includes helper scripts to download and import large datasets into the searchable database. Setup can be resource and disk intensive and the quality of results depends on which datasets you import, so coverage is not global and MaxMind only supplies city-level data; reverse geocoding is partially implemented and a few lookups can still fail, for example some place-name formats like "London, England" are tricky. Recent work (v0.42) improves the import tool robustness, adds OSM PBF support and an LRU cache, and now tries Geo::Address::Parser before libpostal to reduce memory use during parsing.

Log::Abstraction is a simple, flexible logging layer for Perl that lets you send messages to a wide range of targets with a consistent API. You can plug in a code reference for full control, push into an array for tests, append to a file, speak to syslog or journald, or have it send email alerts, and it will fall back to Log::Log4perl as a reasonable default if you do not supply a backend. It supports standard severity levels, runtime configuration from files or environment variables, a configurable text format or a compact JSON output for log aggregation, cloning of logger instances with different thresholds, and a retrievable recent message history for inspection. Advanced behaviours include per-instance email throttling, automatic script-name discovery for syslog, and compatibility with Log::Any via an adapter. The author notes a few limitations to be aware of such as in-place mutation of the syslog configuration hash, structured key/value logging being available only to CODE-ref backends, the email throttle and some flags not being thread-safe, OpenTelemetry not yet supported, and the default-backend path effectively requiring Log::Log4perl. If you want a lightweight, backend-agnostic logger that you can adapt to custom output formats or integrate with system logging and alerting, Log::Abstraction is likely a good fit.

Crypto::Utils is a Perl toolkit that bundles reusable cryptographic helpers and protocol components to make it easier to build secure authentication and key-exchange flows. It provides implementations and utilities for modern PAKEs and related primitives such as CPace, Hash2Curve helpers, the Noise framework, OPAQUE, OPRF, SIGMA, SPAKE2Plus and SPEKE, together with base OpenSSL bindings and FFI C helper code. The module is aimed at Perl developers who want higher-level building blocks for integrating or composing cryptographic protocols instead of reimplementing low-level primitives. The distribution is actively evolving and the 0.003 release merged the bundled OpenSSL base functions into the package.

Mojolicious::Plugin::OIDC is a plugin that makes it easy to add OpenID Connect authentication and OAuth2 access token validation to a Mojolicious web app. It lets your application act as a relying party and as a resource server without becoming an identity provider. The plugin wraps OIDC-Client, creates client objects and callback routes from a simple configuration, and exposes a $c->oidc entry point you can use to trigger login redirects, validate JWT access tokens, build API user agents with token exchange, and map claims into local user fields. It supports multiple providers, claim mapping, audience aliases and expiration leeway, and includes examples for protecting routes and integrating with OpenAPI. The author recommends keeping session and token data on the server side rather than in client cookies for better security.

Catalyst::Plugin::OIDC makes it easy to add OpenID Connect authentication and OAuth 2.0 token validation to a Catalyst web application. It lets your app act as an OpenID Connect relying party and validate access tokens issued by an external authorization server while delegating protocol details to the OIDC::Client library. It does not implement an OpenID Provider. The plugin creates and caches client objects at startup, automatically adds the callback routes, and exposes a simple c->oidc($provider) entry point that returns an OIDC::Client::Plugin object you can use to check identities, redirect users to login, or build API user agents that propagate tokens. Configuration is driven from your Catalyst config where you declare providers, credentials, redirect paths, claim mappings and audience aliases. Recent releases update the dependency to newer OIDC::Client versions and align tests and behavior with upstream changes including support for PKCE. The documentation also highlights a security recommendation to keep session and token data on the server side rather than in client-side cookies.

Net::Blossom::Server::Backend::SQLite provides a SQLite-based storage backend for Net::Blossom::Server that stores blob bytes and metadata together using DBI and DBD::SQLite. It implements the server storage contract and supports schema deployment, beginning uploads, committing and retrieving blobs, fetching descriptors without bodies, deleting blobs or owner relationships, and listing a key's blobs. You can supply a file path or an existing SQLite DBI handle and configure a base_url that the module uses to build public descriptor URLs. This backend is well suited to single-node deployments, local development, and testing and can be acceptable in production when blob size, traffic, and write concurrency are controlled. Blob bodies are kept in SQLite BLOB columns to keep storage simple, so very large media archives or high-traffic public servers will usually prefer Postgres or a backend that stores bytes outside the metadata database.

Database::Abstraction is a read-only Perl ORM that gives you a single, SQL-free interface to tabular data stored as CSV/PSV/XML files, SQLite or BerkeleyDB, and it can also connect to any DBI data source via a DSN. You can perform lookups and scans with plain Perl method calls or use the fluent query builder to express comparisons, wildcards, set and logical operators and automatic joins without writing SQL. Small files may be slurped into memory for sub-millisecond lookups while DBI backends use cached prepared statements for speed, and recent 0.36 work added schema introspection, DSN portability and stricter input validation to reduce injection risks while fixing a Data::Reuse stale-address bug and Windows file-detection issues. The module is intentionally read-only and has a few practical caveats such as a historical default CSV separator of '!' (override with sep_char => ','), limited XML slurp support, slurp mode assuming a unique key column, and reduced features for BerkeleyDB backends, but if you need a lightweight, portable way to query multiple file and database formats without writing SQL this module is a good fit.

SPVM::Go brings the Go language's concurrency model into SPVM by providing goroutines, channels, select, timers, and related helpers so you can write lightweight concurrent tasks and channel-based communication inside an SPVM program. It integrates with libuv to register waits for timers, I/O and channel operations on an event loop so goroutines are suspended without busy-waiting, keeping CPU usage low and allowing many concurrent goroutines. The API lets you spawn goroutines, create buffered or unbuffered channels, use select, sleep, and perform I/O waits, but certain scheduling and I/O wait calls must be made from the main thread and will raise exceptions on invalid timeouts or I/O timeouts. If you want Go-style concurrency primitives in SPVM, SPVM::Go is a practical, efficient port with companion modules and a GitHub repository for more details.

Preproc::Tiny is a minimal, zero-dependency preprocessor that uses plain Perl as its templating language to generate source files from ".pp" templates. You can run it from Perl or the command line and it simply strips the .pp extension to produce the output file while letting you embed Perl with line directives starting with @@ or multi-line snippets between [@ and @]. It offers handy shortcuts for appending to the output and for trimming the extra newline, exposes pp_files and pp_text for batch or in-memory processing, and works by converting the template into Perl and evaling it so any compile error shows the generated code for easy debugging. This module is useful when you want the full expressiveness of Perl inside templates without pulling in a larger templating system.

Crypt::xxHash is a Perl extension that provides very fast non-cryptographic hashing using the xxHash family. It offers 32-bit and 64-bit hash functions, xxHash3 variants including a 128-bit hex output, and convenience routines that return hex strings. A streaming API lets you incrementally update and finalize hashes for large or chunked inputs such as files. The module wraps up-to-date C code and uses native 64-bit arithmetic for performance, and published benchmarks show substantial speed improvements over older Perl bindings. It implements xxHash v0.8.0 and is distributed under the BSD license.

OIDC::Client is a Perl library for acting as an OpenID Connect and OAuth 2.0 client that helps scripts and services perform common authentication tasks such as building authorization URLs, obtaining tokens, verifying JWTs, calling userinfo and introspection endpoints, exchanging tokens for different audiences, and producing API user agents preconfigured with access tokens. It is configuration driven and handles JWT verification with automatic JWK rotation, supports modern client authentication methods including client_secret_basic, client_secret_post, client_secret_jwt, private_key_jwt, tls_client_auth and none, and includes features for PKCE and token renewal and caching. Use it directly from command line tools or batch jobs, or use one of the available framework plugins for Mojolicious, Catalyst or Dancer2 when integrating into a web application. The recent 1.08 release added PKCE support and switched random string generation to Crypt::PRNG for improved security.