CPANscan

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.

Font::FreeType is a Perl wrapper around the FreeType2 library that makes it easy to load font files, inspect metrics and outlines, and render individual glyphs as bitmap images or scalable outlines. You create a Font::FreeType object, open a face from a font file, set a size and resolution, then fetch glyphs by character or code point and obtain bitmaps, metrics, SVG paths and other information. The API is designed to be more Perl-friendly than the raw C interface and supports many font formats that FreeType understands, which makes the module useful for generating text images, exporting glyph outlines to vector formats, building typographic tools, or extracting font metadata. The distribution has been actively maintained with bug fixes, test updates, and added helpers like glyph iteration and load-flag control, but the original author warned the module began life in beta so some values or behaviors can still vary with FreeType versions. If you need programmatic access to fonts from Perl and want high-quality rendering plus outline extraction, this module is likely relevant.

App::PDFUtils is a small collection of command-line helpers that simplify common PDF tasks by wrapping standard tools like qpdf, GhostScript and pdftotext, so you can add or remove passwords, check for protection, compress files, split large documents, extract or grep text, and run batch operations with convenience features such as configuration-file support, multiple-file handling, automatic output naming, and optional backups. The utilities are designed for day-to-day workflows where you want quick, scriptable actions rather than low-level PDF programming, and they expose sensible defaults while letting you pass options like page ranges, overwrite behavior, and multiple password attempts. Because the programs are thin wrappers, they rely on those external command-line tools being available on your system, and the project notes plans to add OCR-based text extraction in the future.

List::Compare is a small, well tested Perl module that makes common list-set operations simple to use by wrapping intersections, unions, differences, symmetric differences and multisets (bags) in an object-oriented API and a parallel functional interface. It works with two or many lists and accepts either array references or seen-hash references, returns results as arrays or array references, and also supplies Boolean queries such as subset, equivalence and disjointness plus simple pretty-printed charts. There is an accelerated mode that defers computation for a single requested comparison and an unsorted option to avoid the cost of sorting when you do not need human-friendly output. The module is mature and actively maintained; recent updates prepared for future Perl strictness and modernized the test suite to use Capture::Tiny.

OPCUA::Open62541 is a Perl XS wrapper for the open62541 C library that lets Perl programs act as OPC UA clients or servers. It exposes objects for Server, Client, Variant, ServerConfig, ClientConfig and a Logger so you can create and configure servers, connect clients, read and write node values, browse address spaces, create subscriptions and monitored items, and register callbacks for asynchronous operations and lifecycle events. The module maps most open62541 functionality into Perl method calls and relies on the open62541 documentation for semantic details. Note that the interface is not yet complete and 64 bit Perl builds are required for 64 bit UA integer types.