CPANscan

DateTime::Lite is a lightweight, low-dependency, drop-in replacement for DateTime that preserves the familiar API while trimming startup cost and installed footprint. It provides full calendar and clock arithmetic, nanosecond-aware timestamps, leap second handling, CLDR and BCP47 locale support including automatic timezone inference from locale tags, and accurate IANA timezone handling by reading TZif binaries and evaluating POSIX footer rules. Performance-critical paths are implemented in XS and the bundled DateTime::Lite::TimeZone uses a compact SQLite store with an optional process-level memory cache so you can get both small initial overhead for short-lived scripts and high throughput for long-running services when needed. Error handling follows a non-fatal, exception-object model by default and serialization, formatting, and duration semantics mirror DateTime closely so most existing DateTime code should work with minimal changes.

HTTP::Date is a small, reliable Perl utility for converting between epoch seconds and the many date string formats you encounter in HTTP headers, log files and system tools. Its commonly used functions are time2str to produce the RFC‑1123/GMT timestamp expected by HTTP and str2time to turn a wide range of human and machine date strings back into epoch seconds, with an optional default time zone and support for named zones when Time::Zone is installed. The module also exposes parse_date which returns numeric date components or an ISO‑like string and understands formats such as RFC1123/RFC850, ISO 8601, common logfile timestamps, ctime/asctime, Unix ls and Windows dir output, while treating numeric-only dates as day/month/year rather than US month/day/year. Helper routines time2iso and time2isoz format times in local or UTC ISO style. Note that parsing dates before your system epoch may not work on all platforms and that parse_date now rejects input longer than 64 characters to avoid pathological regex backtracking attacks, a security fix addressing CVE-2026-14741.

Backblaze::B2V4 is a Perl client for Backblaze B2 Cloud Storage that wraps the service's V4 API and makes it easy to authenticate, upload and download files, manage buckets, and query file metadata from Perl scripts. You create a client with your application key and key id and then call simple methods to upload single files or large files, download by file name or by Backblaze file id, list files in a bucket, create or delete buckets, and remove file versions. The module also exposes a generic send_request method for calls not covered by the helper methods and includes a b2_client command line utility for quick get and put operations. It defaults new buckets to server side encryption and notes that bucket names must be globally unique, and the installer can test your credentials by downloading a small file if you provide test environment variables. If you already use an S3 integration you might prefer Backblaze's S3-compatible API and S3 modules, but this package is a straightforward choice for Perl projects that want native B2 V4 support.

Dist::Zilla::PluginBundle::GEEKRUTH is an opinionated, ready-made Dist::Zilla configuration that bundles and preconfigures the collection of plugins D. Ruth Holloway uses to build, test, version and release Perl distributions. It automates common release work such as contributor tracking, metadata (MetaYAML/MetaJSON), POD weaving and README generation, compile and release tests, automatic prerequisite detection, changelog and semantic versioning, and the git commit/tag/push steps so you do not have to assemble all those pieces yourself. You can tweak a few arguments like authority (default cpan:GEEKRUTH), builder (default MakeMaker), development and release branch names, upstream remote, autoprereqs_skip and a remove_plugin option to drop parts you do not want. This bundle is most useful if you want a proven, full-featured release pipeline modeled on Ruthie’s workflow rather than a minimal or highly bespoke setup. Recent notable changes moved the workflow to Codeberg and added a SecurityPolicy plugin.

Data::PubSub::Shared provides a lightweight, high-performance publish/subscribe system built on Linux shared memory that lets multiple processes broadcast messages into a ring buffer while each subscriber reads independently from its own cursor. Publishers never remove messages and the ring overwrites old data when full, with automatic recovery for slow subscribers and per-subscriber overflow counters to track lost messages. The module offers several types: Int, Int32, and Int16 deliver lock-free multi-producer multi-consumer publishing for compact numeric payloads and are ideal for counters, timestamps, or small events, while Str handles variable-length byte or UTF-8 strings and is better for log lines, JSON, or serialized payloads at the cost of a mutex that serializes publishers. It supports file-backed or anonymous mappings, memfd-backed sharing, futex-based blocking polls with timeouts, eventfd integration for event loops, batch operations for very high throughput, and tools for cursor management and diagnostic status. Note that it is Linux-only and requires 64-bit Perl, Str-mode publishers are serialized and recover from a dead publisher within a short timeout, and certain operations such as clearing the ring must be used carefully when publishers are active. Overall it is a practical choice when you need very fast interprocess fan-out with low overhead and simple APIs for both numeric and string messages.

DateTime::TimeZone is the core Perl module that represents time zones for the DateTime ecosystem and provides a factory for creating zone objects by name, offset, or special types like UTC or a floating zone for calendar-local times. It gives you the current offset and DST status for a DateTime object, converts human-friendly offset strings to seconds and back, and exposes catalogs of valid zone names, categories, country mappings, and links so you can present or validate time zone choices. The module hides the complex historical and DST rules by using generated Olson/IANA data and includes platform-specific helpers for discovering the system "local" zone on Windows, HPUX, Android, and others. It also provides Storable hooks to avoid bloating serialized data and advises loading needed zones in a parent process for preforked servers to save memory. This release tracks the 2026c Olson updates and includes contemporary changes affecting Alberta, Canada and Morocco.

Data::NDArray::Shared provides a compact, typed N‑dimensional numeric array that lives in a Linux shared memory mapping so multiple processes can view and mutate the same dense tensor concurrently. You can create file-backed arrays, anonymous mappings inherited across fork, or transferable memfd-backed mappings and reopen them from a file descriptor; supported element types include double and float and a range of signed and unsigned integer widths and shapes of one to eight dimensions with row‑major layout. The module gives simple indexed and flat access, bulk fills and zeroing, reshape without copying, reductions like sum/mean/min/max, in-place scalar and elementwise arithmetic, and convenient conversion to and from PDL when available, including an optional zero-copy PDL alias that bypasses the module lock and therefore requires external synchronization. Concurrent mutation is serialized with a futex write‑preferring read/write lock that recovers from dead processes so readers see consistent headers and writers do not corrupt the buffer. Limitations worth noting are Linux-only operation, 64‑bit Perl required, a 1 TiB mapping cap and integer dtypes that wrap per C casting rules and float dtypes that lose precision relative to Perl NVs. Recent 0.02 hardens security and robustness by creating backing files with mode 0600 by default and adding an option to supply an explicit file mode for intentional cross-user sharing.

Data::HashMap::Shared is a high-performance, file-backed shared-memory hash map for 64-bit Linux Perl that makes it simple to share keyed data and counters between processes without a database. It offers type-specialized variants for integer and string keys and values, a lock-free fast read path with futex-backed write locking, atomic increment/decrement and compare-and-swap operations, optional LRU eviction and per-key TTLs for use as a cross-process cache, and an arena allocator for storing larger strings in shared mmap space. You can create anonymous or memfd-backed maps, shard a workload across multiple files for parallel writers, and use either a method API or very fast XS keyword calls. The module exposes batch ops, cursors, diagnostics and explicit sync/unlink controls and is tuned for low-latency lookups and very high throughput versus LMDB and BerkeleyDB in the author’s benchmarks. Important caveats are that it is Linux-only and requires 64-bit Perl, integer variants use fixed-width two’s-complement storage so keys and values can wrap or be truncated, string keys compare by raw bytes with UTF-8 flags preserved but not part of identity, and stale-lock recovery assumes a shared PID namespace so cross-container use is unsupported; after a writer crash a map may contain a partially-updated entry so critical systems should clear after recovery. Overall it is a practical choice when you need very fast, concurrent cross-process caches, counters, queues or other shared data structures without running a separate server.

Data::Graph::Shared provides a compact, high-performance directed weighted graph that multiple Linux processes can attach to via shared memory, letting you allocate a fixed pool of nodes and edges and mutate the structure safely from different processes. It supports fast node and edge insertion, neighbor iteration, node data storage, and counters for nodes and edges, with mutex-protected updates and PID-based recovery for stale locks so concurrent programs stay robust. The graph can be file-backed or use memfd, exposes an eventfd for integration with event loops, and includes diagnostic stats and sync/unlink lifecycle controls; backing files are created with restrictive permissions by default. One design tradeoff to note is that remove_node only clears outgoing edges in O(1) and leaves incoming destinations dangling unless you use remove_node_full, which does an O(N+E) cleanup. This module is Linux-only and requires 64-bit Perl, and bench tests in its documentation show very high operation throughput for single-process workloads.

Data::Deque::Shared provides a high-performance double-ended queue that multiple Linux processes can share via anonymous mappings, memfd or file-backed shared memory, offering lock-free push and pop operations at both ends with futex-based blocking when empty or full. It comes in integer and fixed-length string variants, is designed for 64-bit Perl and capacities up to 2^31, and is targeted at multi-producer multi-consumer workloads where it outperforms older shared-string queues under contention. The API is simple: push/pop (with optional timed waits), size and capacity queries, a concurrency-safe drain operation, eventfd integration and stats that include recoveries for crashed or stalled pushers. Backing files are created with secure owner-only permissions by default and the module validates on-attach headers so attachments are safer, but if you grant write access to other users you must trust those processes not to corrupt the mapping. Recent releases hardened security and robustness, moved to a file format v2 with per-slot control data for true MPMC safety, added bounded recovery of stuck slots, and preserved UTF-8 for the string variant.

Data::Buffer::Shared provides typed, fixed-capacity buffers that live in file-backed or anonymous mmap'd shared memory so multiple processes can read and update the same data directly on Linux using 64-bit Perl. Each type variant (integers, floats, fixed-length strings) exposes atomic, lock-free single-element get/set and rich integer atomics like incr/add/CAS plus seqlock-guarded bulk reads and writes, a futex-based read/write lock with stale-lock recovery, zero-copy mmap views and raw pointers for FFI, and both keyword and method APIs for convenience. Buffers are presized and available via on-disk files, memfd objects, or anonymous mappings, making this module a good fit for high-performance IPC tasks such as counters, shared arrays, and low-latency state sharing. Backing files are created with owner-only permissions (0600) by default for improved security and you can supply an explicit file mode to share across users. Recent releases focus on security and robustness, notably the 0600 default file mode and improved dead-reader recovery, and a header version bump in 0.04 means older maps from 0.03 must be recreated.

Data::Intern::Shared provides a compact, shared-memory string interning table for Linux that maps byte strings to dense uint32 ids and back, storing each distinct string once so several processes can agree on and cheaply reference the same keys. It is useful when you want shared data structures to hold fixed-size ids instead of variable-length strings, for example to build string-keyed sorted sets by pairing it with Data::SortedSet::Shared. The module supports anonymous mappings inherited across fork, file-backed mappings, and transferable memfd descriptors so unrelated processes can attach, lookups are constant-time, and concurrent access is guarded by a futex-based write-preferring rwlock with dead-process recovery. Interning is append-only and permanent so ids stay stable for the life of the table, empty strings and embedded NULs are allowed, and limits are fixed at construction: byte-level keys only, a max number of strings and a capped arena size, and no per-string removal. Note that it is Linux-only and requires 64-bit Perl. The recent release tightened security and robustness by creating backing files with owner-only (0600) permissions by default while still permitting an explicit file mode for cross-user sharing.

RT-Extension-ExcelFeed is a plugin for Request Tracker that adds Microsoft Excel (XLSX) export capabilities so search results and scheduled dashboard reports can be saved or emailed as native Excel files. It integrates into the Query Builder feeds menu with a "Download as Microsoft Excel Spreadsheet" option and lets you send dashboard subscriptions as attached XLSX files instead of inline HTML. The extension targets RT 6.0 (with older 0.* releases for RT 5.0), installs as a standard RT plugin, and includes simple configuration switches to hide the chart download button and to control progressive row paging so large reports can be generated with lower memory use. If you need readable, portable Excel output from RT searches or scheduled reports, this extension provides a direct and easy way to produce it.

Sereal::Encoder is a fast, compact binary serializer for Perl that turns complex Perl data structures into the Sereal format (protocol version 5 by default) for efficient caching, IPC, storage or network transport. You create a persistent encoder object and call encode or use the faster sereal_encode_with_object functional wrapper to serialize data, or write straight to disk with encode_to_file. The encoder supports optional payload compression with Snappy, Zlib or Zstd, string deduplication and several safety and compatibility controls such as refusing or stripping bless information, stringifying or undefing unknown values, and freeze/ thaw callbacks so objects can control their own serialized representation. It also offers options to produce more deterministic output for cache keys and testing with canonical, canonical_refs and sort_keys, and tuning for exotic floating point support or to force standard doubles. Be aware that deep nested structures can hit recursion limits, that producing a truly canonical representation is inherently tricky in Perl because of string/number duality and other edge cases, and that encoder and decoder are released separately so you should upgrade the decoder before upgrading to encoder protocol 5. Recent notable changes include official protocol 5 support with better floating point handling and Perl 5.36 boolean support, plus ongoing build and compression library updates.

Sereal::Decoder is a high-performance Perl module for deserializing the compact binary Sereal format, letting Perl programs efficiently reconstruct complex data structures produced by Sereal::Encoder. It supports protocol versions 1 through 4 and offers both object-oriented and faster functional call styles, plus conveniences like decoding with headers, offset-based and incremental parsing, and a bytes_consumed counter to detect leftover data. The decoder includes many safety and tuning options such as refusing Snappy compression, refusing or preventing blessing of objects, disabling THAW callbacks, UTF-8 validation, and limits on recursion depth, string/array/hash sizes and uncompressed blob size to help mitigate malformed- or malicious-input attacks. It also implements the FREEZE/THAW object protocol for custom object serialization while refusing to autoload classes by default, so you can opt out if you do not trust input. Be aware that very deep nesting can exhaust the C stack and that Snappy decompression has historically been a source of unsafe behavior on invalid input, so use the provided options when handling untrusted data. This module is a good fit for Perl services that need fast, compact binary interchange, caching, or IPC where speed and space efficiency matter.

Sereal is a high-performance, compact binary serialization system for Perl that makes it easy to pack complex Perl data structures into small, fast-to-parse blobs and unpack them again. This top-level Sereal module is a thin wrapper that loads and coordinates the real workhorses Sereal::Encoder and Sereal::Decoder, provides shared encoder/decoder objects, simple functional helpers like encode_sereal and decode_sereal, file read/write helpers, and utilities to detect Sereal data, and it exposes constants for compression choices such as snappy, zlib and zstd. If you care about speed you should prefer the object oriented API or the with_object variants rather than the stateless convenience functions. Note that releases emphasize safe upgrade ordering so you should upgrade decoders before encoders, and recent releases add protocol 5 improvements including better floating point handling and broader compression and platform support.

Time::OlsonTZ::Data packages a specific release of the Olson (IANA) timezone database for Perl, making ready-to-use binary tzfiles and useful metadata available to programs. You can query the embedded database version, list canonical timezone names and their aliases, get the alias-to-canonical mappings, and fetch a country-oriented selection to help humans pick a geographical timezone, and you can ask for the pathname of the binary tzfile for any named zone. It is intended for developers who need accurate, regularly updated timezone information in their Perl apps or who want to ship the standard tzfile format with their code. The module is updated as the IANA database changes so users should plan to refresh it periodically for current rules, and long-running programs should load needed tzfiles early to avoid surprising behavior if the module is updated while running.

Crypt::Sodium::XS is a Perl XS wrapper around the libsodium cryptography library that gives you access to modern primitives for encryption, signatures, hashing, key derivation and password hashing through both object-oriented and procedural APIs. It emphasizes memory safety by returning sensitive values in protected MemVault objects and exposes libsodium features such as secretbox, box, aead, secretstream, kdf/hkdf, pwhash, generichash and low-level curve25519 operations so you can build higher-level crypto tools without reimplementing primitives. The distribution prefers using a system-installed libsodium but can build with a bundled copy and supports environment variables to control which library is used. It is new and marked experimental so it is not recommended for production use, it is not intended for multi-threaded programs and portability outside POSIX-like systems is limited. Recent updates bumped the bundled libsodium to 1.0.22 and added support for KEM, SHA-3 and XOF algorithms, and the project has received multiple security fixes and ongoing maintenance.

CPAN::Perl::Releases is a small utility module that ships a curated, static mapping of every Perl release on CPAN to the relative "authors/id/" paths where the release tarballs live, making it easy for scripts and tools to locate specific perl distribution files. Its main function, perl_tarballs, returns a hash reference that maps archive types like tar.gz, tar.bz2 or tar.xz to the CPAN author path for a given Perl version, and helper functions list the supported perl_versions and the PAUSE IDs of Perl pumpkins. The data is updated as new perl releases are published to CPAN so the module is useful for installers, mirrors, release trackers or any automation that needs precise tarball locations. Not every release has every compression format, and the changelog shows frequent updates with the latest entries adding support for recent releases such as v5.44.0-RC2.

Test::Mockingbird is a testing utility for Perl that lets you replace or wrap functions and constructors, inject fake dependencies into modules, record and inspect calls, and verify call ordering so your tests can run with controlled, isolated behavior. It provides simple functions to install mocks that return fixed values, exceptions, sequences, or custom coderefs, to spy on calls while letting the original run, to intercept new() constructors, and to inject objects into a package; mocks can be stacked, scoped to a guard object, or fully restored with restore_all. Be aware of a couple of practical limits: auto-vivified symbol table entries can make Package->can() appear true after unmocking so use defined(&Package::method) to test callability, and spy() can emit a prototype-mismatch warning when wrapping prototyped subs. In the recent 0.11 release several bug fixes were applied (including a fix for scoped restore_all and prototype-warning leakage) and new async support landed as a companion module Test::Mockingbird::Async that adds Future-based mock helpers and async spies, plus convenience features like inject_all and assert_call_order. If you write Perl test suites that need fine-grained control over dependencies, call flow, or asynchronous behavior, this module gives a compact, stackable API to create deterministic, inspectable test doubles.

App::Codit is a Perl/Tk based integrated development environment and text editor designed for Perl programmers. It offers a multi document interface with tabs and a left-side document list and uses the Tk::CodeText widget to provide syntax highlighting, code folding, smart word-aware undo/redo, auto indentation, bracket pairing, autocomplete, bookmarks and configurable tab and indent styles. The app is highly extensible through a plugin system and ships with plugins for common tasks like backups, Git integration, file browsing, snippets, a console and Pod viewing. You can customize the UI and editing behavior through a configuration window or command line options for config folders, icon themes, sessions and plugin selection. Built on the Tk::AppWindow framework, Codit exposes extension points and methods for adding tool panes and sidebars. The project has been under active development and was considered beta around version 0.10, with documentation and an issue tracker available for further support.

Tk::ListBrowser is a Perl/Tk widget that gives you a flexible, icon-capable list and browser control for graphical applications. It supports multiple layout modes including bar, column, row, list, hlist and tree so you can switch between grid, columnar and hierarchical views while keeping your data. Items can carry images, multiline text and arbitrary data, and you can add sortable headers and side columns, filter live with Ctrl+F, navigate and select with keyboard or mouse, and programmatically add, remove, hide, sort and refresh entries. Scrollbars are handled automatically and many visual and behavioral options are configurable to match your UI needs. Be aware that using custom fonts may noticeably slow refresh performance.

Tk::DocumentTree is a Perl/Tk megawidget that provides a simple file or document browser by combining a label with an ITree widget and automatically building a folder hierarchy as you add entries. It shows the common path for all entries in the label, supports entries marked as regular files or as untracked items, and uses icons to indicate file, folder and modified/saved status with customizable callbacks for supplying icons and handling selection. The widget exposes convenient methods to add, delete, select and reveal entries, mark entries modified or saved, expand or collapse the tree, and retrieve lists of tracked or untracked files. It accepts most ITree options but reserves a few (for example -itemtype, -browsecmd, -separator, -selectmode and -exportselection) and ships with sensible default icons and a right‑click context menu that you can customize. This module is a good fit for Perl/Tk applications that need an integrated, editable document or project tree without building the widget from scratch.

Crypt::OpenSSL::SignCSR is a small XS-based Perl module that uses OpenSSL to sign a PEM-format Certificate Signing Request and produce a X.509 certificate, making it easy to generate certificates from CSRs in Perl programs. You create a Signer with your private key and optional parameters, then call sign($csr) to get the certificate back in PEM, text, or DER form. You can control the signature digest (for example SHA256), the certificate validity in days, and the output format via the constructor or provided setters, and recent releases added DER output, a security policy and fixed several memory leaks and portability issues. Note that sign() now accepts only the CSR itself and other options must be provided through the constructor or setter methods.

App::GUI::GoLP is a Perl/Prima graphical tool for loading, running and editing Life-like cellular automata from common .rle and .cells pattern files. Backed by the Game::Life::Faster engine it provides an interactive canvas with play, pause and single-step controls, zooming, autogrow and grid toggles, plus save and PNG snapshot support and simple keyboard and mouse interaction. An Edit Mode pauses the simulation and lets you toggle cells directly with the mouse for quick experimentation. Color options let you choose static colors or dynamic age-based palettes and version 1.3 added several color maps such as Plasma, Viridis and Inferno for clearer age visualization. Licensed under GPLv3 this app is a handy, lightweight front end for hobbyists, educators or anyone who wants an interactive way to explore Conway-style patterns.

Album is a Perl module for creating and maintaining browser-ready photo albums that organize your pictures into a simple directory layout with index pages, thumbnails, optional medium-size images, and per-image HTML pages. It can generate thumbnails and medium images, embed other albums, attach descriptions, tags and EXIF-derived metadata, and work on images in place or import them from a camera or CD. The module requires Image::Magick (and ImageMagick), Image::Info and File::Spec, and can use optional external tools such as jpegtran, mplayer and mencoder for lossless rotation and basic video handling. Album is aimed at straightforward, maintainable digital albums rather than slick slideshow web shows. Be aware that some older Perl releases had Data::Dumper issues with non-ASCII data, with Perl 5.6.x and 5.8.3 or later recommended.

Business::NAB is a top‑level Perl namespace that groups a set of focused modules for parsing and creating the file formats used to exchange payments, reports and acknowledgements with the National Australia Bank. The distribution itself does not implement processing logic but provides access to modules for BPAY batch payments and remittance files, Australian Direct Entry payments, returns and reports, NAI/BAI2 account information files, XML acknowledgements and a Types package that supplies reusable type constraints for the namespace. It is a practical choice when you need to generate or consume NAB-specific electronic payment and reporting files from Perl, and recent fixes include handling signed amounts in BAI files and left‑padding account numbers shorter than nine digits to match NAB expectations.

OpenSearch::Client is an unofficial Perl client that lets Perl applications talk to OpenSearch clusters for indexing, searching and cluster management. It was created when OpenSearch forked away from Elasticsearch and is derived from the familiar Search::Elasticsearch API, so existing Perl code using that client can be adapted more easily. The module defaults to connecting to localhost:9200 and provides a comprehensive API surface with documentation available in OpenSearch::Client::Manual. This distribution is maintained by Mark Dootson, is released under the Apache 2.0 license, and the 3.007.000 series represents the initial release with subsequent minor pod updates.

DBIx::QuickORM is a Perl DSL and toolkit for declaring and composing database-backed object models so you can define ORMs, servers, databases, schemas, tables, columns, links, custom row classes and plugins in a clear, reusable way. It supports schema autofill from live databases, multiple SQL dialects and DBI drivers, custom types and row/handle classes, and a DSL-free quick() path for immediate use. The project is still in early development so expect active change and occasional breaking updates while it stabilizes, but recent work has focused on reliability and safety including secure identifier quoting, improved type affinity detection, better trigger and generated-column handling, and a new volatile-column feature that auto-detects fields the database may set on write and lazily refreshes them instead of keeping stale values. If you want a flexible, declarative way to build compact ORMs and value database introspection and pluginability, QuickORM is worth a look, especially if you can tolerate being an early adopter.

Text::MarkdownAdoc is a pure-Perl converter that turns Markdown documents into clean AsciiDoc suitable for processing with Asciidoctor. It focuses on GitHub-Flavored Markdown plus kramdown extensions such as definition lists and footnotes while also supporting CommonMark as a subset. You instantiate a converter with optional default AsciiDoc attributes and call convert to produce AsciiDoc output, with per-call options merged into the constructor defaults so you can override attributes for individual conversions. This module is a lightweight, native-Perl option if you need to programmatically convert Markdown to AsciiDoc in Perl-based workflows. This is the first public release, version 0.1.0.