CPANscan

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.

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.

Data::NestedKey is an object-oriented Perl helper for easily inspecting and modifying deeply nested hash and array structures using simple dot-separated path strings with optional [n] array subscripts. It lets you read, delete and check for deeply nested values without manual traversal and supports convenient set semantics such as a + prefix to append or merge and a - prefix to remove keys or array elements. Array subscripts are supported for get, exists_key and delete but not for set, and you cannot set directly against an array-rooted structure so arrays must be retrieved and edited directly when needed. The object can also serialize its contents to JSON, YAML, Data::Dumper or Storable and includes options for pretty JSON output, making it handy for manipulating configuration files and API responses.

App::Test::Generator is a toolset for automatically creating black‑box tests for Perl code by turning compact input/output schemas into runnable Test::Most test harnesses that combine randomized fuzzing, deterministic edge cases, optional static corpora, and property‑based tests. It reads YAML or programmatic schemas that describe a routine's parameters and return types and emits reproducible fuzz tests with semantic generators (emails, UUIDs, timestamps, etc.), boundary checks, and optional Test::LectroTest properties, and it can be driven from the command line or used from Perl. The distribution also bundles mutation testing, LCSAJ path metrics, a test-quality dashboard that aggregates Devel::Cover and CPAN Testers data, schema extraction from Perl sources, benchmark script generation, and helpers to deploy GitHub Actions workflows so you can run scheduled fuzzing and collect CI-driven improvements. A recent 0.42 release added corpus minimization to keep fuzz corpora small while preserving coverage, a pod-example tester to turn POD examples into round‑trip tests, a benchmark-generator, and a deploy-workflows command plus better CPAN Testers reproduction scripts, making it especially useful for CPAN authors who want to harden their modules against edge cases and automate continuous fuzz and mutation-driven quality improvement.

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.

Imager::File::TIFF is the TIFF read/write plugin for the Imager image toolkit, letting Perl programs load and save TIFF images and query available TIFF compression codecs. It integrates libtiff so you can pick compression by numeric code or libtiff name and it exposes helper methods to report the libtiff build and runtime versions used by the module. The code aims for robust handling across multiple libtiff releases and includes fixes for warnings handling and memory leaks introduced by libtiff interactions. A few edge cases remain, for example mixed SampleFormat values may not always be handled perfectly because libtiff can expose only the first value, but most common TIFFs are supported and recent releases have improved compatibility and stability. If you use Imager and need reliable TIFF support or want to enumerate compression options, this module is the relevant interface.

Imager::File::JPEG is the JPEG plugin for the Imager image toolkit that lets you read and write JPEG files and also query the underlying libjpeg implementation used at build time. You use it through Imager for normal image IO and you can call its helpers to get the libjpeg type and version and to detect whether it was built with libjpeg-turbo or mozjpeg. The module also reports support for arithmetic coding and whether encoding or decoding of arithmetic coding is available. This is useful when you need to know which JPEG features and performance characteristics are available on your system.

Imager is a mature, full-featured Perl library for creating, reading, writing and manipulating bitmap images across many common formats. You can draw primitives, render text with font metrics, apply filters and effects, blend and composite images, and perform transformations like scale, crop and rotate, with fine control over color, palettes and alpha channels. It is well suited to generating thumbnails, server-side image processing, simple graphics generation and batch image workflows where you want a Perl-native API rather than calling external tools. The module is actively maintained and recent releases include important security and robustness fixes, for example Imager 1.033 resolves an EXIF parsing issue and fixes several memory leaks, so keep installations current for production use.