CPANscan

Genealogy::Military::Branch is a compact Perl module that scans free‑text military service notes from genealogy records and returns the branch named, for example "navy", "RAF" or "Royal Engineers". It supports common British, US and Commonwealth patterns and returns results localized to the system language or to a language you supply at construction. The API is simple: construct a detector with optional language and warn_on_error settings, then call detect with the text to scan; it never returns undef and will return a generic localized "military" when no specific branch is found. Patterns are tried from most specific to least so phrases like "Merchant Navy" are identified correctly. The module was created to replace duplicated helper code in related genealogy distributions and is intended to be extended with additional Commonwealth and US branch patterns in future.

DBIx::QuickDB makes it trivial to spin up temporary, disposable database servers for testing or local development across multiple engines so you can get a real DB to connect to with minimal setup. You can declare named databases at compile time that provide constants or build them on the fly at runtime and each returned DB object exposes a connect method. Supported drivers include PostgreSQL, MySQL variants, SQLite and, as of the latest release, an optional DuckDB driver when DBD::DuckDB and the duckdb CLI are available. Configuration is flexible via a spec hash where you control autostart/autostop, bootstrap and cleanup behavior, a custom directory, explicit driver choices or a list of acceptable drivers, and preload SQL files so your schema is ready. The module is designed for test isolation and convenience with features like cloning and pools, it defaults to cleaning up temporary directories so do not point it at anything important, and recent releases improved cleanup and fixed leaks while adding DuckDB support.

Concierge::Users is a Perl module that provides a ready-made user data layer with a clear two-step workflow for setup and runtime. During setup you define the storage backend, choose which built-in and custom fields you want, and the module writes a config and prepares storage, archiving any existing data to avoid loss. At runtime you load that config and get a simple CRUD API for registering, retrieving, updating, listing and deleting users, with consistent hashref return values indicating success or failure. You can store users in SQLite, a flat CSV or TSV file, or individual YAML files depending on your needs, and all backends expose the same interface. Field validation is built in with many common validators and can be enforced or skipped for bulk imports, and list_users supports a compact filter DSL for queries. Concierge::Users pairs with Concierge::Auth and Concierge::Sessions but also works standalone, making it useful when you want a configurable, schema-driven user store without writing storage plumbing yourself.

Concierge::Sessions is a Perl session manager that provides a simple factory-style API for creating, retrieving, deleting and cleaning up user sessions while letting you choose where those sessions are stored. It supports a production-ready SQLite backend and a lightweight JSON file backend for testing, enforces one active session per user, offers sliding-window expiration plus optional indefinite sessions, and returns consistent service-style hashrefs so your application can handle success and error conditions cleanly. The module is modern Perl (v5.36+) and is suited for web apps, APIs, or any service that needs application-controlled, serializable session data with optional persistence and periodic cleanup. Recent releases expanded test coverage and earlier updates hardened session ID generation for improved security.

Concierge::Auth is a compact Perl authentication component that hashes passwords with Argon2 while accepting legacy bcrypt hashes for smooth migration, stores credentials in a locked, file-based store, and also provides a suite of cryptographically secure token and random-value generators. It validates user IDs and passwords against sensible length and character rules, exposes safe file management utilities, and follows a non-throwing API where methods return a boolean plus an explanatory message so callers can handle outcomes gracefully. The generators can be used even when no password file is configured and include v4 UUIDs, hex IDs, alphanumeric tokens, random strings, and word-based passphrases produced via Crypt::PRNG rather than external programs. The project integrates with the broader Concierge suite but works standalone, and recent releases have cleaned up deprecated token APIs and improved generator behavior while expanding test coverage for greater reliability.

Thunderhorse is a modern, async-ready Perl web framework built natively on the PAGI protocol that aims to be light, extensible and hackable for real-time web applications. It includes a cache-friendly router with rich placeholder and bridge semantics, controller-based organization, modules for logging, templating and middleware, a flexible configuration system with smart merging rules, and a CLI for scaffolding and inspecting projects. The framework deliberately keeps dependencies small and leverages Perl 5.40 language features for performance and clarity, making it easy to mount PAGI apps or reuse components elsewhere. The project is currently in beta so APIs may change before the planned 1.000 release, but recent releases added a lazily created stash and a session object on the request Context to simplify session-aware handlers and avoid unnecessary work when the stash is unused. If you are building asynchronous or real-time services with PAGI and want a minimal, well-organized framework that integrates PAGI middleware and promotes reuse, Thunderhorse is worth evaluating.

Gears is a modular toolkit for building web frameworks in Perl that supplies the core building blocks you need, including an application container, a component system with lifecycle hooks, controllers, routing, configuration, templating, logging and request context handling. It is intended as a foundation rather than a full opinionated framework so you can mix, extend or replace components to shape the behavior you want in your own framework. The distribution also provides convenient utilities such as load_component to lazily load component classes and get_component_name to compose component namespaces from short names. Gears is currently in beta so APIs may change until a stable 1.000 release, and recent updates include test fixes and a small bugfix for a logger namespace issue.

Dist::Zilla::Plugin::IRC is a tiny Dist::Zilla plugin that adds an IRC channel entry to your distribution metadata so users can find the project's chat room. You enable it in your dist.ini with a stanza like [IRC] and channel = distzilla and you can optionally set network (defaults to "perl" but accepts values such as "libera", "freenode", or "oftc") or supply an explicit host to control the resulting link. It is useful when you want to advertise a real-time support or community channel alongside other resources in your CPAN distribution.

Task::Devel::Essentials is a lightweight meta-module that installs a curated toolkit of commonly used Perl modules so you can set up a developer environment with one cpan or cpanm command. It brings together testing and QA tools, profilers, packaging helpers, object systems like Moose/Moo/Mouse, JSON/YAML, file and date utilities, networking and MIME helpers, and many small conveniences that most Perl authors use every day, with a few optional XS or GNU-readline variants included where available. If you want a ready-made collection rather than picking dozens of dependencies by hand, this bundle saves time and keeps your toolchain consistent. The package was recently bumped to newer bundled versions, added CPAN::DistnameInfo, and moved its repository and issue tracker to Codeberg.

ClearPress is a lightweight, pragmatic Perl web framework that provides a simple, scaffolded way to build CRUD-style applications with a loosely MVC-inspired layout. It prescribes a project structure with a controller script, model and view modules, and Template Toolkit templates so you can quickly create list, add, edit, read, update and delete pages. Models are explicit Perl classes that declare their fields and use Class::Accessor-generated accessors instead of inspecting the database for schema, and the framework offers helpers for common associations and templates get convenient objects like the requestor and model injected. There is no built-in authentication and views behave more like controllers than in a strict MVC pattern, but that minimalism makes ClearPress well suited for rapid development and straightforward deployment using standard Perl components such as CGI, Template and Config::IniFiles.

Perl7::Handy provides a Perl 7-style scripting environment for older Perl 5 interpreters by importing safer, modern defaults into the caller package. It enables strict and warnings where supported, disables legacy bareword filehandles and multidimensional array emulation, enables subroutine signatures on capable Perls, lexically disables the indirect call feature, and removes the current directory from @INC to address a known security issue. The module runs on Perl 5.00503 and later and will use optional helper modules when available, with some behaviors only available on newer Perl releases. Use Perl7::Handy when you want the safer, modern defaults of Perl 7 for your scripts without upgrading your Perl interpreter.

Params::Validate::Strict is a Perl utility for checking and coercing function or API parameters against a rich, declarative schema so you can enforce types and business rules before your code runs. You describe each parameter with simple types or detailed rules for length, numeric ranges, regexes, allowed or forbidden values, transforms, defaults and optionality, and the module also supports nested structures, per-element checks for arrays, reusable custom types, cross-field validators and relationship rules like mutually exclusive or required groups. Validation returns a new hashref of validated and coerced values or dies with a clear error by default though you can configure warnings or ignore unknown parameters and plug in a logger. It is handy for API input checking, web application firewalls, improving documentation and driving black-box test case generation.

Mojo::SQLite is a lightweight Mojolicious-aware wrapper around DBD::SQLite that makes embedding SQLite in web apps straightforward by providing pooled, fork-safe connections, built‑in schema migrations, SQL generation via SQL::Abstract::Pg and convenient query and result helpers. It uses synchronous DBI calls and raises exceptions for errors, supports transactions and JSON parameters, caches handles for performance and emits a connection event when new connections are created. You can enable WAL journaling for better concurrent read/write behavior but note that as of v4.0.0 WAL is off by default for new databases and remains persistent once set, and in-memory databases are per-connection only. If you need a compact, well integrated SQLite backend for a Mojolicious app with easy migrations and CRUD generation, Mojo::SQLite is a good fit.

Net::BCCN is a small Perl module that implements a lightweight LISTEN/NOTIFY style notification fabric over UDP broadcast for a single local network segment. It lets processes and machines broadcast short, opaque messages on named channels without a central broker so you can publish events with notify(channel,payload) and receive them with listen(channel,options). The module handles socket setup, optional per-message deduplication and simple message-rate statistics, and uses nonblocking I/O with an optional timeout for efficient polling. It is intentionally fire-and-forget with no acknowledgements, persistence, or replay so occasional packet loss is expected. Envelope-level integrity and directed or multicast delivery are part of the protocol design but are not yet implemented in this release. This is the initial CPAN release (version 1.11, 2026-05-25).

Protocol::Tus is a Perl implementation of the Tus resumable upload protocol that makes it easy to accept, resume, and manage large file uploads from web clients. It offers a framework-agnostic API centered on HTTP_request, which takes an HTTP method, headers, an optional upload id and a body scalar reference and returns a Protocol::Tus::Response object for your application to turn into an HTTP reply. Storage is pluggable via a model object that implements the Protocol::Tus::AbstractModel interface or via a class spec such as Protocol::Tus::LocalDir for filesystem storage. Convenience methods cover the common HTTP verbs used by Tus including POST, PATCH, HEAD, OPTIONS and DELETE and the module honors X-HTTP-Method-Override for middleware compatibility. You can supply an id_to_location callback to generate Location headers after creating uploads and you are responsible for mapping URL paths to upload identifiers. Methods return response objects rather than throwing exceptions and the module requires Perl 5.24 or later. This is the initial 0.001 release.

IO::Tty is a low-level Perl module that allocates pseudo-terminals and exports the constants you need to work with them, but it is intended to be used internally by IO::Pty so most users should use IO::Pty to create ptys rather than calling IO::Tty directly. It supports modern POSIX systems and Cygwin and is tested on Linux, macOS, FreeBSD, OpenBSD and NetBSD, with known platform quirks documented in the POD because pty behavior is system dependent. The module is useful if you need direct control over pty allocation or just want the ioctl and terminal constants from IO::Tty::Constant. Recent 1.31 fixes a regression that stopped the slave from becoming a controlling terminal by always passing O_NOCTTY and improves openpty detection on some glibc builds.

YAML::Syck is a fast, lightweight Perl interface to the libsyck serializer that converts Perl data structures to YAML and back with simple functions like Load, Dump, LoadFile and DumpFile, plus newer encoding-aware helpers such as LoadBytes and LoadUTF8. It is designed for speed and interoperability with other Syck/YAML bindings and offers configurable behaviors through global flags for implicit typing, Unicode handling, key sorting and how code or blessed objects are treated. The module implements YAML 1.0 and bundles its own libsyck sources, so it may not match newer YAML 1.1/1.2 semantics and the author notes it has known issues and is only semi-actively maintained, so you may prefer YAML::XS for strict YAML 1.1/1.2 compatibility. Recent maintenance releases have fixed a number of parsing and memory issues and, as of 1.46, ensure numeric-looking strings are preserved as strings when dumping and accept trailing commas in flow sequences and mappings for better round-trip fidelity.

Concierge is a lightweight service-layer orchestrator that centralizes user authentication, session management, and user record storage for Perl applications, presenting a single, simple API and Concierge::User objects instead of exposing the underlying components. It wires together three pluggable cores for passwords, sessions, and user data so you can create a "desk" directory with Concierge::Setup and then open that desk at runtime to register users, create visitor or guest sessions, authenticate logins, restore users from cookies, and manage user records and passwords, with every method returning a clear success/message result rather than throwing exceptions. The module supports anonymous visitors, temporary guest sessions that can be upgraded to logged-in accounts, and persistent user records, and it persists a random user_key mapping to make cookie-based restores reliable. If you need custom backends or extra record types you can swap any of the core components for a drop-in replacement and add new components that follow the same conventions. The recent 0.7.0 release added Concierge::Base and expanded the extensibility documentation to make building and attaching new components easier.

App::Test::Generator is a toolkit that automates the creation of thorough test harnesses for Perl modules by turning simple input/output schemas into ready-to-run .t scripts that mix randomized fuzzing, deterministic boundary checks, optional static corpora, and property-based tests. You feed it a YAML or Perl schema describing function parameters and expected outputs and it generates Test::Most/Test::LectroTest-based tests that handle functional and OO calls, seedable reproducible fuzz runs, semantic generators for realistic data, transform-based invariants, and configurable edge cases for strings, numbers, arrays and hashes. The suite ties into mutation testing and LCSAJ metrics so surviving mutants can drive new schemas and tests, and it can produce a mutation and coverage dashboard and CI-ready workflows for continuous fuzzing. Helpers for serializing Perl values into test code and a SchemaExtractor that infers schemas from POD and source make it easy to bootstrap tests from existing modules. The recent 0.39 release tightens the mutation dashboard scoring and fixes a range of SchemaExtractor edge cases by adding Input formal spec parsing, better list-return handling, and several false positive fixes so the generated schemas and mutant-guided tests are more accurate and reliable.

Error::Show is a utility for locating and diagnosing Perl syntax errors and runtime exceptions by printing numbered, annotated source code around the problem and a readable stack trace. You can enable it from the command line with -MError::Show to have Perl run normally while the module intercepts syntax errors and warnings and emits context, optionally piping explanations through the diagnostics helper splain. Inside programs it exports a context function that accepts a die string or common CPAN exception objects and returns nicely formatted code snippets and frame context, and it integrates with several popular exception classes. For debugging dynamically generated code it provides streval, which preserves the original string so Error::Show can show accurate context and traces, and throw to create a simple exception object with captured frames when you need a lightweight throw. Recent releases added streval and throw and in v0.5.1 introduced an option to limit reported call stack depth while tidying output formatting. You can tune output with options for pre and post lines, limits, reversing order, and whether to include the raw Perl error text, and you should note it does not support programs supplied via STDIN or Perl -e and -E switches and splain may produce more output than ideal.

Git::Libgit2 provides low-level FFI::Platypus bindings to the libgit2 C library via Alien::Libgit2 so you can call libgit2 functions directly from Perl. It exposes a near-C API for initializing and shutting down the library, querying the version, checking return codes and converting object IDs, and for working with repositories, refs, blobs, trees and commits as well as remotes and authentication, clone/fetch/push operations, revwalks, branches, tags, diffs, status and related helpers. The module is intentionally close to the C surface, making it a good fit when you need direct, fine-grained control or plan to build higher-level helpers, and if you prefer an idiomatic Perl wrapper with RAII you can use Git::Native instead. This initial 0.001 release ships a broad set of bindings and has been tested against libgit2 1.5 and 1.9.

WWW::MailboxOrg is a Perl client for the Mailbox.org API that makes it simple to automate and manage Mailbox.org accounts and services from Perl programs. It speaks JSON-RPC 2.0 over HTTPS and uses session tokens for authentication, letting you log in and out and then call API areas such as account, domain, mail, mailing list, blacklist, spam protection, video chat, backup, invoices, password reset, validation and utility functions through dedicated helper objects. The module defaults to the official API endpoint and stores the session token for subsequent calls so you can focus on tasks like listing accounts, querying domain info or managing mail settings rather than HTTP plumbing. It is suitable for Perl developers who need to integrate Mailbox.org administration or mail workflows into scripts and applications, and links to the upstream API documentation and a GitHub issue tracker for support and contributions.

Travel::Status::DE::DBRIS is an unofficial Perl client for bahn.de that helps you fetch live departure boards, search stations by name or coordinates, and retrieve trip details and carriage formation for German trains. You can use it synchronously or asynchronously with promises and Mojo::UserAgent, and it returns rich objects for departures, journeys, locations, and formations so you can easily display times, delays, lines, destinations and route stops. The module supports optional caching to reduce repeated realtime requests, a failure cache to avoid hammering the backend, filtering by modes of transit, fetching intermediate stops, and injecting prepared JSON for testing. It is actively maintained but still described as work in progress and includes mitigations for Deutsche Bahn's rate limiting and web application firewall, so you should use sensible caching and request rates. Recent releases add nicer location output by showing distances when GIS::Distance is installed and keep train and operator names up to date to match backend changes.

Hypersonic is a Perl micro HTTP server that JIT-compiles your routes and its event loop into native C so the hot path can run with virtually no Perl overhead, delivering very high throughput. Static route handlers are executed once at compile() time and their complete HTTP responses are baked into C as constants, while dynamic routes still invoke Perl per request with JIT-compiled request objects where needed. It supports WebSocket connections and optional room-based broadcasts, server-sent events and streaming responses, TLS via OpenSSL, gzip compression compiled into the server, sessions, an async thread pool, and on-disk caching of compiled XS modules, so it is well suited for low-latency APIs, static asset serving, and benchmarking. You register routes with familiar get/post/websocket/static methods, call compile() to generate and build the native code, then run() to start workers and listen on a port. The module is explicitly performance-focused and claims very high request rates, and its JIT features require a C toolchain and native libraries such as zlib for compression and OpenSSL for TLS.

File::Copy::clonefile is a tiny Perl wrapper around the clonefile system call that lets you request a filesystem-level clone of a file from Perl. It exports a single function, clonefile, which you call with a source and destination path and then check the return value and $! on error. Because it delegates to the underlying clonefile syscall it only works on platforms that provide that facility, for example macOS, so it is useful when you need fast, space-efficient copies on systems that support copy-on-write cloning but not applicable on other platforms.

Perl500503Syntax::OrDie is a simple compatibility watchdog that helps you catch syntax and runtime constructs introduced after Perl 5.005_03 before you deploy to old systems. When you add use Perl500503Syntax::OrDie to a script it reads the calling file, masks comments and quoted literals, scans for newer language features and regex constructs, and dies with a filename and line number if anything unsupported is found. It also installs runtime guards to prevent certain unsupported uses of open and mkdir, and provides a programmatic API so you can scan strings or files on demand or run it from the command line. The module intentionally does not inspect the contents of string literals or the bodies of regexes and it is not a full Perl lexer so unusual quoting or dynamically generated code may evade or trigger false alarms. It is written to run on Perl 5.005_03 through modern releases, but be aware that its CORE::GLOBAL:: overrides affect the whole interpreter so it is not intended for use inside production processes.

File::FindRoot is a small Perl utility for locating a project's root directory by walking up the filesystem from a starting point until it finds a file, directory name, or pattern you specify. You give it a relative path or regex and it returns the ancestor directory that contains that target or undef if none is found. You can also supply a custom callback to decide what counts as a match, and tune behavior with options such as start_at to change the starting directory, limit to cap how many ancestors are checked, and debug/debug_fh to see progress. The module is minimal and easy to drop into scripts that need to locate config files, libraries, or VCS markers without relying on fixed paths. This is a newly released module with its initial user release in May 2026.

CPANSA::DB provides the CPAN Security Advisory reports as a ready-to-use Perl data structure, primarily to feed tools like CPAN::Audit but available to any code that needs a curated list of security advisories for CPAN distributions. You access it with CPANSA::DB->db and get a hashref of reports, and a matching JSON file is also provided if you prefer non-Perl consumption. Releases are published on GitHub and shipped with both GPG signatures and GitHub attestations so you can verify an archive came from the official source before trusting the data. The database is actively maintained with frequent updates and has recently been made more compact by switching to a terser internal format, so it is a convenient, verifiable source for integrating CPAN security information into scanners, audits, or dashboards.

HP::Handy is a compact, single-file template engine that brings Jinja2-style templating to Perl 5.5.3 and later without any external dependencies. It offers familiar {{ }} variable output, {% %} control tags, filters, tests, loops, template inheritance, macros and includes, plus simple customization like auto-escaping and configurable delimiters, and it exposes render_file and render_string methods as well as hooks to add custom filters and tests. The implementation is intentionally minimal and portable, using a regex-based evaluator so you can drop the file into small web projects or pair it with HTTP::Handy and DB::Handy to build a lightweight MVC stack. Because templates are parsed on each render there is no compiled cache, recursion and some advanced features like super or imports are not supported, and string operations are byte-oriented to preserve compatibility with older Perl versions. If you need a zero-dependency, Jinja-compatible templating layer for legacy or small-scale Perl apps, HP::Handy is a practical and easy-to-use choice.

aozora is a greple module for proofreading texts destined for Aozora Bunko that scans Japanese documents for common OCR and transcription problems, odd punctuation and spacing, kana and katakana anomalies, ruby/annotation issues, rare or old character usage, and other formatting oddities. It integrates with the greple search tool and exposes many command line checks you can enable to flag likely errors so you can inspect and fix them before submission. The module speeds up quality control for contributors preparing texts for Aozora Bunko, but it only highlights potential issues and can produce false positives, so manual review is still required.