CPANscan

Number::Iterator is a small, easy-to-use Perl helper for stepping a numeric value forward and backward: you construct an iterator with a configurable interval and then advance or retreat it with overloaded ++ and -- or with iterate/deiterate methods, read or set the current value and interval, and even supply custom iterate and deiterate callbacks to implement any progression logic such as multiplying, dividing, or other transforms. It is useful for generating numeric series, encapsulating counter behavior, or keeping progression logic out of application code, and the recent 1.03 release was a minor packaging cleanup that removed pax headers.

Tlaloc lets you attach an invisible "wetness" level to any Perl scalar that automatically decays each time the variable is read, turning a normal value into a tiny stateful object without changing its string or numeric content. Wetness is an integer from 0 to 100 and evaporates by a configurable rate (default 10) on every access, with helper functions to wet (add 50), drench (set to 100), dry (remove the magic), query wetness or dryness, and get or set the evaporation rate, and an optional tied wrapper that extends the same behavior to array and hash elements when you want passive evaporation on element reads. The module is mainly a playful but practical way to attach transient metadata to variables, for example to simulate time-limited state or to experiment with per-value lifecycle behavior. Note the usual magic caveats: attaching to literals is futile because temporaries are freed, the magic lives per SV so copying a scalar does not copy its wetness, the tied wrappers control which operations trigger evaporation, and the implementation is not thread safe.

LRU::Cache provides a fast in-memory least-recently-used cache for Perl, implemented in C for maximum throughput. You create it with a fixed capacity and it automatically evicts the least recently used item when full, with all common operations such as set, get, delete, exists and peek running in constant time. There is a normal object API and a function-style API you can import for roughly 2x to 3x better performance, gets promote items to the front while peek and exists do not, and you can query size, capacity, list keys in most-recent-first order or fetch the newest and oldest entries. It is ideal for caching database results, computed values, or any hot data you want to keep in memory to cut latency. Recent changes fixed test issues on older Perls and improved compatibility with pre-5.14 Perls and Windows builds so the module works cleanly across a wider range of Perl versions.

Map::Tube::API is a lightweight Perl client for the Map::Tube REST service that makes it easy to query metro maps and routing information from Perl code; the service is currently in beta and does not require an API key. You create the client with optional base_url and version parameters or by setting MAP_BASE_URL and MAP_VERSION in the environment, and then call simple methods to get data: shortest_route to compute a route between two named stations, line_stations to list stations on a specific line, map_stations to list all stations on a map, and available_maps to discover which city maps are supported. It is intended for Perl developers who need programmatic access to subway routing and station lists rather than building their own routing backend. The recent v1.0.0 release adds a real unit test suite with a mockable user agent to validate URL construction and error handling without network access, and strengthens parameter validation to make the client more robust.

Litavis is a high-performance CSS preprocessor and compiler you use from Perl that implements its engine in C for speed and correctness. It accepts CSS with conveniences such as nested selectors, parent references, preprocessor variables, mixins, and map variables, resolves colour functions like lighten or mix at compile time, and emits either minified or pretty-printed CSS. The tool preserves input order to avoid hash randomisation issues, offers cascade-aware deduplication with configurable aggressiveness, hoists @import and @charset rules, and supports multi-file projects via parse_file and parse_dir while allowing repeated compile calls without mutating internal state and a reset method to clear accumulated data. It also passes through modern CSS features such as custom properties and calc, can write output directly to a file, and exposes its reusable C header files for downstream XS modules that want to embed the same engine. If you need a fast, predictable Perl-accessible way to author and compile enhanced CSS with compile-time colour math and safe rule merging, Litavis is likely relevant.

Map::Tube::London is a Perl library that packages a ready-made dataset of London Underground stations and lines and exposes a simple API to find routes and produce map images. You instantiate it with new and call get_shortest_route($from,$to) to receive a Map::Tube::Route object describing the shortest path between two station names, with errors thrown as Map::Tube::Exception. The distribution includes station data for Bakerloo, Central, Circle, District, DLR, Hammersmith & City, Jubilee, Metropolitan, Northern, London Overground, Piccadilly, Victoria and Waterloo & City lines. If you install Map::Tube::Plugin::Graph you can call as_image($line_name) to get a base64 encoded PNG of a specific line or the whole map when no line is specified. The module is handy for scripts, tools or small web services that need routing or static tube maps, integrates with the Map::Tube ecosystem, is maintained on GitHub and in the recent v2.0.2 release its dependency on Map::Tube was updated to v5.1.0.

MojoX::MojoDbWrap is a small, practical adapter that normalizes the common parts of Mojo::Pg, Mojo::SQLite and similar database objects and adds a few handy helpers so you can treat different backends the same way. It forwards basic calls like select to the underlying DB handle, exposes the wrapped object and its class, and provides convenience routines id_of and id_or_insert for finding a record id by condition or creating the row and returning its id when missing, with support for custom id column names. It also integrates optional migrations via a migrations_for mapping and is extensible through a wrappers or inserter_for mechanism so you can plug in custom creation and insert logic or pass an existing DB object. The module is aimed at Mojolicious users or any Perl app that needs a lightweight, uniform DB interface across Pg, SQLite or custom drivers, requires Perl 5.24 or later, and was formally released as an official distribution in version 0.002.

Mojolicious::Plugin::BarefootJS is a small plugin that integrates the BarefootJS server runtime into a Mojolicious application. It registers a helper named "bf" that lazily provides a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo and lets you render compiled marked templates as native Mojolicious templates. Install it with $self->plugin('BarefootJS') to expose the helper in controllers and templates, and use BarefootJS::Backend::Xslate if you need the same runtime outside Mojolicious. The module is actively maintained and is released under the MIT license.

BarefootJS::Backend::Xslate is a small adapter that lets the BarefootJS runtime render Kolon-format Text::Xslate templates. It either accepts a ready-made Text::Xslate object or builds one from a list of template paths and options, configures HTML auto-escaping, and provides the runtime hooks BarefootJS expects such as render_named which binds the runtime as the bf object, mark_raw for raw HTML, and a customizable JSON encoder. The module is framework-agnostic so it runs under PSGI/Plack or in plain scripts, and it is intended to be used with the @barefootjs/xslate compile-time adapter that emits .tx templates calling runtime helpers as bf methods. If you use BarefootJS and prefer Kolon/Text::Xslate templates this backend connects the two with minimal configuration.

BarefootJS provides a server-side runtime for templates compiled from JSX/TSX so you can render marked templates and produce client JavaScript from Perl without locking into a particular template engine or web framework. Compiled templates call the runtime for helpers, while backend plugins handle engine-specific tasks like JSON marshalling, raw-string marking, JSX children materialization and named-template rendering. The core uses only Perl core modules and you add a backend when you need one; shipping backends include Text::Xslate for PSGI/Plack and a Mojolicious integration. If you want to generate and render JSX/TSX-based templates from Perl while keeping the freedom to choose your rendering stack, BarefootJS is a lightweight, backend-driven option and it has seen active development with multiple releases through July 2026.

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.