CPANscan

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.

Markdown::Perl is a pure‑Perl, highly configurable Markdown‑to‑HTML processor that implements the CommonMark spec, supports GitHub Flavored Markdown and many extensions, and is the library behind the pmarkdown command‑line tool. You can use it as an object or via functional calls, select predefined modes to emulate other processors or set granular options to tweak parsing, and it returns decoded Unicode output. The module offers hook points so you can resolve unresolved link references or receive parsed YAML front matter, and recent releases added directive container blocks and support for modern YAML parsers such as YAML::PP to improve metadata handling. If you need a portable, extensible Perl Markdown engine that handles CommonMark, GFM, YAML metadata and custom processing hooks, this module is a strong fit.

Chandra::Game::Tetris is a compact Perl module that provides a playable Tetris implementation built on the Chandra game framework. You start it simply by creating a new game object and calling run, and gameplay uses the arrow keys for movement and rotation with space for a hard drop. It is useful as a small demo of Chandra, a learning example for writing games in Perl, or a lightweight game component you can extend or embed in projects. The module is an initial 0.01 release by LNATION, distributed under the Artistic License 2.0, and represents a straightforward, minimal first version rather than a fully featured gaming library.

Chandra is a lightweight Perl wrapper around the webview-c library that lets you build cross-platform desktop interfaces using HTML, CSS and JavaScript while driving the UI from Perl. It provides a simple API to create a native window, run or manually control the event loop, evaluate JavaScript from Perl and register Perl callbacks that can be invoked from JavaScript, plus convenience methods for resizing, setting the title, toggling fullscreen, injecting CSS and controlling background color. Chandra supports macOS, Linux and Windows and will use the modern Edge WebView2 on Windows when available with an automatic fallback to the older MSHTML engine, so installing the WebView2 runtime gives the best experience. The module includes examples for binding JavaScript to Perl and a higher level wrapper in Chandra::App for common application patterns.

Chandra::EPUB is a small Perl module that provides a simple desktop EPUB reader built on the Chandra GUI toolkit. It lets you open an EPUB file, extract CSS, chapters and images, and display the book in a window whose width, height and title you can set. The API is intentionally minimal: call new or the convenience open method to load a file, then run to start the reader, and use helper functions like load_epub and extract_body if you need access to the raw content. This module is ideal for Perl developers who want a quick, lightweight GUI reader rather than a full featured EPUB engine, and it is early stage so you should expect basic functionality and report bugs or feature requests through the CPAN tracker.

Net::Nostr::Core is a focused Perl toolkit that implements the core data types and protocol utilities for the Nostr decentralized messaging protocol. It provides modules like Net::Nostr::Event, Net::Nostr::Key, Net::Nostr::Filter and Net::Nostr::Message so you can create, sign, filter and process Nostr events and messages, and it is the foundation used by client and relay distributions. This first independent release splits core protocol functionality out of the larger Net::Nostr distribution, targets the current NIP set as of 2026-07-01, and makes HTTP support optional by lazy-loading AnyEvent::HTTP only for NIP-05 lookup and verification. If you want a full client or relay stack use the Net::Nostr shim which pulls in the recommended dependencies, but if you only need protocol primitives for building or testing Nostr tools, Net::Nostr::Core gives a compact, minimal implementation.

Timer::Wheel is a lightweight, high-performance timer scheduler for Perl that lets you schedule one-shot or recurring callbacks by absolute epoch or relative delay and then fire them by calling tick, making it easy to run stand-alone or integrate with an event loop by invoking tick periodically. It supports grouping timers for bulk cancellation, pausing and resuming individual timers or the entire wheel, and provides helpers to inspect the next deadline and number of pending timers. The implementation uses a priority heap for efficient inserts and peeks and is optimized for fast object construction, so it is a good choice when you want a simple, dependency-light timing facility rather than a full async framework. The current 0.02 release fixes packaging pax headers and the module is distributed under the Artistic License 2.0.

App::karr is the core module behind the karr command line tool that implements a Git-native kanban board kept entirely in Git refs under refs/karr, with task cards stored as Markdown plus YAML frontmatter and board configuration kept in refs rather than in checked-in files. Commands build a temporary board view, let you create, list and update tasks, then serialize changes back into refs and push them, which keeps your repository free of a persistent board tree and avoids usual file-level merge conflicts for shared task state. The distribution includes Docker images for running karr without installing Perl and exposes lower-level modules like App::karr::Git, App::karr::BoardStore and App::karr::Task for programmatic automation, including loading tasks, allocating ids, saving tasks and taking snapshots. The CLI auto-discovers a repository by walking upward from your current directory and shows a quick board summary when run with no subcommand, making it a practical choice if you want task tracking that treats Git as the transport and single source of truth.

Heap::PQ is a compact, C-backed binary heap for Perl that gives you fast min or max priority queues with three ways to use it: an OO API, a functional API that uses custom ops for compile-time speedups, and a raw array API for maximum performance. It supports normal values, a numeric-native variant that stores doubles without SV overhead, custom comparator callbacks for complex objects, and a special dot-separated key-path option that extracts numeric keys at push time so comparisons stay in C and run very quickly. Typical uses are task scheduling, leaderboards, top-k selection and any scenario that needs efficient push, pop, peek and peek_n operations. The module is tuned for speed in benchmarks and recent releases have focused on Perl compatibility fixes and comparator optimizations and bug fixes to improve stability across Perl versions.

EBook::Ishmael is the core Perl module behind the ishmael ebook dumper, providing a programmatic interface to initialize and run the tool and to extract ebook contents and metadata in a variety of forms. You can create an instance with init (which reads @ARGV), then call run or use methods to dump formatted text, raw text, HTML, cover images, identify file formats, or export metadata as ishmael, JSON or XML. It supports many common ebook formats and falls back to external formatters when needed, includes heuristics to guess encodings, and is designed for embedding ishmael functionality in scripts or extending it. This is developer-level documentation, so consult the ishmael manual for user-facing options. Recent updates improve HTML cleanup and namespace handling for EPUB and FictionBook2 files so the module produces cleaner HTML output from namespaced formats.

Date::Holidays::GB is a Perl module that provides UK public and bank holiday dates (data current through 2028) and simple routines to query them. It exports holidays, is_holiday and next_holiday so you can list holidays for a given year or set of regions, check whether a specific date is a holiday (accepting year/month/day or a YYYY-MM-DD string), and find the next holiday for one or more regions. Queries can be limited to England & Wales (EAW), Scotland (SCT) or Northern Ireland (NIR), or you can use region-specific subclasses for convenience. Results come back as hashrefs keyed by MMDD with human readable names and region tags, and the dataset is generated from the official UK government JSON files with a date_generated stamp, although published future dates can occasionally change after release.

PDF::Make is a comprehensive Perl toolkit for creating, reading, and editing PDF files. It offers a recommended high-level, chainable Builder API that handles page layout, coordinate translation, word wrap, fonts, images, tables of contents, and common shapes so you can assemble reports and forms with minimal fuss. For cases that need full control it also exposes a low-level XS API that maps directly to PDF objects, content streams, and page structure. The distribution includes parsers and extractors for text, annotations and tables, support for standard and TrueType fonts, image embedding, interactive features and forms, layers and attachments, redaction and metadata sanitisation, color spaces, encryption and digital signatures, and optional linearisation for fast web view. It has minimal runtime dependencies and is actively maintained; the recent 0.06 release fixes PDF real-number formatting and addresses an XS allocation/compile issue to improve portability on Windows and other builds.

File::Raw is a performance-focused file utility for Perl that bypasses PerlIO and uses direct system calls to read, write, copy, memory-map and inspect files with minimal overhead. It exposes convenient helpers like slurp/spew, append, atomic_spew, efficient line streaming via each_line, a memory-efficient line iterator, head/tail/range access, and a cached stat API to avoid repeated syscalls. The module also includes an extensible plugin system so you can register format or transform plugins in Perl or C and chain byte-level filters like gzip with record-level parsers like CSV, with an XS API for native plugins when you need per-call performance. Platform-specific optimizations such as sendfile on Linux and copyfile on macOS are used where available and the module provides atomic writes and zero-copy mmap reads for large files. Note that plugin-backed iterators are eager and each_line is the recommended streaming path for memory-bounded processing, and you can clear the internal stat cache if external processes change files. If your work involves high-throughput file IO, large or compressed files, or custom format pipelines, File::Raw is a relevant choice. The most recent release fixes a Perl 5.12 build incompatibility to improve compatibility on older Perls.

DBI is the de facto database interface for Perl that gives you a single, consistent API for connecting to and talking to many different databases via driver modules (DBD::*) so your code can be portable across engines. It does not implement database engines itself but dispatches calls to DBD drivers and supplies conveniences for common tasks like connect/connect_cached, prepare/prepare_cached, execute, fetching rows as arrays or hashes, bulk operations, quoting and identifier quoting, transaction control with AutoCommit/commit/rollback, and utilities such as last_insert_id and selectrow_hashref. It also supports placeholders to help avoid SQL injection, attributes and callbacks to control error handling and tracing, and helpers for performance and debugging like execute_array and built in trace/profile hooks. If you write Perl programs that access SQL databases DBI is essential and you should use it together with the specific DBD driver for your database and consult the driver documentation for engine specific behavior.

Bijection::XS is a tiny, fast Perl extension for turning integers into short, human-friendly strings and converting those strings back to the original integers. It exposes simple functions named biject and inverse, and lets you customize the character alphabet with bijection_set and add an integer offset with offset_set for basic obfuscation or namespace shifting. The module ships with a URL-friendly alphanumeric default set and benchmarks show it is several times faster than the pure-Perl equivalent, so it is well suited for high-throughput tasks like generating short IDs, compact database keys, or URL shorteners. Documentation is available via perldoc and the distribution is on CPAN with standard bug reporting.

Bijection is a compact Perl module that turns integers into short, reversible strings and back again, exporting biject to produce a bijected string and inverse to recover the original integer. It lets you customize the symbol set with bijection_set and apply a numeric offset with offset_set, and it ships with a predefined list of letters and digits by default. Because the mapping is a true bijection it is deterministic and invertible, making this module handy for creating compact identifiers, human-friendly codes, or simple obfuscation of numeric IDs for use in URLs, logs, or short tokens.