CPANscan

Travel::Status::DE::DBRIS is an unofficial Perl client for Deutsche Bahn's bahn.de departure monitor and train info APIs that lets developers fetch station departure boards, search stations by name or location, request trip details and, where available, carriage formation data. It works synchronously or asynchronously via promises and Mojo::UserAgent and returns tidy objects representing stations, departures and journeys so you can print schedules, delays, routes or coach layouts in your own tools. The module supports caching of successful and failed requests, filtering by transport mode, loading prepared JSON for testing, and various timeout and user agent options to cope with the real backend. Note that the project is still a work in progress and the author warns that Deutsche Bahn’s WAF can throttle or block aggressive request patterns, so the module includes mitigations such as randomized headers and configurable failure caching, and the default timeout was recently raised to 20 seconds; a small API change in 0.25 removed a couple of formation accessors because that data is no longer provided upstream.

Test::Unit is a Perl implementation of the JUnit-style unit testing framework that helps you write, organize and run automated tests in an object-oriented way while also offering a simpler procedural wrapper for scripting-style usage. The distribution points you to the core pieces such as Test::Unit::TestCase and Test::Unit::TestSuite and includes runners and listeners for different reporting styles, a Tk GUI runner, assertions for deep structure comparison, regex and coderef checks, and facilities for composing suites and filtering tests. It is a mature, actively maintained project with a long history of refinements and fixes, and recent releases addressed test stability issues including a major fix that prevents non-Error exceptions from being lost during test runs so early-terminated tests are reported correctly. Test::Unit is free software distributed under the same terms as Perl, either the Artistic License or the GNU GPL.

Email::Abuse::Investigator is a Perl module that turns a raw spam or phishing message into actionable intelligence by parsing headers and bodies to identify the likely originating IPv4 address, extract all HTTP/HTTPS links and contact domains, resolve hostnames to IPs, and query RDAP/WHOIS to find network owners and abuse contacts. It collates MX and NS data, parses DKIM and list-unsubscribe headers, flags recently registered or lookalike domains, and produces a weighted risk assessment plus both an analyst-friendly full report and a compact, send-ready abuse report with deduplicated recipient addresses. The analyser is configurable with timeouts and trusted-relay exclusions and caches results per parsed message to avoid repeated lookups. It is designed to help security teams and abuse desks quickly determine who to contact and what evidence to include when reporting malicious mail. Note that the module extracts only IPv4 addresses, is not thread-safe, and WHOIS timeouts may be unreliable on some platforms such as Windows.

EBook::Ishmael is the core Perl module that powers ishmael, a command line ebook dumper, and provides a simple programmatic interface to extract content and metadata from ebook files. It parses command line options, creates an object via init, and can dump ebook text, raw text, HTML, various metadata forms including JSON and XML, extract cover images, and identify file formats, so you can embed those capabilities in scripts or drive them from the command line using run. This module is intended for developers rather than end users, so consult the ishmael manual for user-focused documentation. The project is open source on Codeberg and maintained by Samuel Young under the GPL.

Eshu is a fast, XS-powered tool for normalizing leading indentation in C, Perl and XS source files by tracking nesting and rewriting only the whitespace at the start of each line while leaving the rest of the code untouched. It understands language-specific constructs that affect indentation including C strings, comments and preprocessor directives, Perl heredocs, regexes and pod sections, and XS dual-mode files with XSUB boundaries and labels. The module exposes simple entry points to fix C, Perl or XS text or to auto-dispatch by language, and it can detect language from a filename. You can choose tabs or spaces and set the indentation width, and there is an option to indent preprocessor directives when desired. Eshu is implemented in C for single-pass speed and ships with a command line utility for in-place fixing, diffs, CI checks or stdin/stdout processing, making it a practical choice for keeping mixed-language codebases consistently indented.

CallBackery is a Mojolicious-based application designed to build appliance-style frontends by wiring web requests to your application logic. It centralizes configuration via CallBackery::Config with a default file at etc/callbackery.cfg that can be overridden by the CALLBACKERY_CONF environment variable. The module integrates with a CallBackery::Database-compatible backend, lets you add securityHeaders to improve browser-side protections, and provides hooks for RPC service namespace and controller wiring plus a docIndex for an initial documentation page. Initialization and routing are handled in the standard Mojolicious startup method so the app behaves like any other Mojolicious application while providing these frontend-focused conveniences. The project is GPL licensed and maintained by Tobias Oetiker.

WWW::Noss is the internal backend for noss, the command-line RSS/Atom reader and aggregator, and implements the program's behavior rather than providing a public API. It initializes from command-line arguments and exposes methods that map directly to user commands such as update, reload, read, open, list, unread, mark, post, feeds, groups, clean, discover, and import/export of OPML so the noss front end can manage feeds, posts, and formatting. Consult the noss manual for end-user documentation since this module is intended to be used by the noss tool itself. Recent releases have added features like compressed feed support, a discover command to find feed URLs on web pages, colored and customizable output, MRSS support, and better concurrent access to the database, and the latest 2.03 change makes list with --list-limit and --sort date return the last N posts by default.

YAML::Syck is a fast, lightweight Perl binding to the libsyck serializer that converts Perl data structures to and from YAML using simple functions like Load, Dump, LoadFile and DumpFile. It gives you control over common behaviors through package flags such as ImplicitTyping for recognizing booleans and numbers, ImplicitUnicode and ImplicitBinary for Unicode and binary handling, Headless to omit the leading document marker, SortKeys to sort hash keys, and UseCode/LoadCode/DumpCode and LoadBlessed to control evaling of code and blessing of objects. For precise encoding control it also offers LoadBytes, LoadUTF8, DumpBytes and DumpUTF8 so you can treat input and output explicitly as bytes or UTF-8. The module implements YAML 1.0 and aims for interoperability with other syck implementations, so it is handy when you need fast YAML round trips or to match Ruby/other Syck wrappers, but if you require strict YAML 1.1 compliance you should consider YAML::XS instead. Recent maintenance has addressed many parsing and security issues and the 1.42 release improved YAML 1.0 compliance and added support for the YAML merge key while fixing a number of parsing and leak bugs, though the POD warns there are still known issues and some edge cases where other libraries may be preferable.

GD::Thumbnail is a lightweight Perl utility that uses GD to produce small preview images from files, filehandles, or raw image data and returns raw image bytes you can save or stream. It is designed for web galleries and similar tasks and can automatically add optional info strips showing the original file size, resolution and MIME type, or render those strips as overlays so they do not change the thumbnail height. You can request square or cropped thumbnails, add a one pixel frame, force output format, and control strip and text colors and fonts, with recent releases adding TrueType font support and fixing background fill issues. After creation you can query the thumbnail MIME type, width and height and the module will throw an exception on error so you may want to wrap calls in an eval. Note that supported input and output formats are limited to the image types GD supports such as PNG, JPEG and GIF.

App::Prove::Plugin::Metrics is a small plugin for the prove test runner that emits pass/fail metrics for your Perl unit tests so you can collect test pass-rates automatically. It builds metric names from configurable pieces such as a prefix, separator, test filename, subtest path and optionally assertion labels, and you can control how deep subtest paths go, which characters are allowed in names, and whether values are boolean or rollup percentages. By default it writes metrics to a plain file but you can instead point it at a custom module that implements a save function and optional configureHarness defaults. The plugin assumes prove is using the standard console formatter and rollup behavior may change, but recent 0.0.3 fixes improve handling of subtests by distinguishing subtest names from assertion labels, bubbling subtest names as labels by default, and handling unlabeled assertions and "No tests run for subtest" failures. If you need lightweight, configurable test metrics emitted at test runtime this plugin is a convenient option.

XML::Parser is a long‑standing Perl interface for reading and validating XML that wraps the fast Expat library and gives you multiple convenient ways to work with XML: you can parse a complete string or file, feed it an open handle or stream documents incrementally with a non‑blocking parser, and choose from built‑in "styles" that either call your subs for each element, build a Tree or Objects representation, print a Debug outline, or drive a Stream-style callback API. The module is driven by event handlers (Start, End, Char, etc.) that receive the underlying Expat parser object and let you handle markup, CDATA, DTD and external entities, with sensible defaults that use either file access or LWP for external URIs and options to control namespaces, encodings and entity expansion. Error handling is exception‑based and can include contextual lines around parse errors when you enable ErrorContext, and the Tree/Objects styles return convenient in‑memory structures if you prefer to work with a parsed representation instead of callbacks. The latest releases modernize compatibility and safety: recent fixes restrict the Subs style to package‑local subs to avoid accidental dispatch into inherited methods and the distribution now targets Perl 5.8 and later while improving robustness and encoding support. If you need a mature, flexible Perl parser that exposes low‑level Expat features but adds higher‑level styles and convenient error and encoding handling, XML::Parser is a solid choice.

IO::Tty is a low-level Perl interface for allocating pseudo-terminal devices and for importing related system constants, intended primarily as the backend for the higher-level IO::Pty module rather than for direct day-to-day use. If you only need to create and manage ptys in Perl you should reach for IO::Pty, but IO::Tty is useful when you want direct access to pty allocation behavior or need the platform-specific constants found in IO::Tty::Constant. The module targets POSIX-style systems and is known to work on many Unix variants and on Windows only under Cygwin, so its behavior can vary by platform and a few quirks are documented such as some systems returning EIO instead of EOF, the slave EOF not being reported back to the master in certain BSDs and Solaris, and occasional ioctl/TIOCSCTTY issues on OpenBSD. If you plan to use it be prepared for system-specific differences and testing on your target environment, otherwise rely on IO::Pty for most tasks.

Colouring::In::XS is a fast, XS-backed Perl module for creating, converting and manipulating colors in a variety of common formats. You can instantiate colors from hex, RGB(A), HSL(A) or arrays and convert them to hex, rgb/rgba, hsl, hsv or Terminal::ANSIColor strings, with automatic CSS-friendly stringification. It also provides color operations such as mix, lighten, darken, tint, shade, saturate, desaturate, greyscale and opacity control via fade/fadein/fadeout, plus a validator for input colors. The implementation in XS makes it much faster than a pure-Perl equivalent, so it is a good fit for web or terminal applications and scripts that need reliable color math and high performance.

FFI::Platypus lets Perl code call functions in compiled libraries without writing XS by using libffi to bridge to C, C++, Rust, Go, Fortran and other languages that produce native code. It provides a simple API to load dynamic libraries, declare native types or custom type handlers, and either create callable function objects or attach functions as fast native xsubs, plus support for callbacks, variadic functions, structured records and memory buffers so you can handle strings, pointers and objects idiomatically from Perl. The module includes helpers and language plugins for platform quirks, integrates with FFI::CheckLib and FFI::Build for finding and bundling libraries, and encourages use of API level 2 for the latest behavior and conveniences. It does depend on dynamic library support and libffi on the host system and is intended for modern Perls, and the current 2.11 release contains documentation updates to keep examples and guidance current.

PDF::API2 is a mature Perl library for creating, modifying, and inspecting PDF documents from code. You can start a new PDF or open an existing file, add or import pages, place text, images, and barcodes, and use built-in or external fonts including TrueType and Type1. It also exposes document metadata, outlines (bookmarks), viewer preferences, open actions, colorspaces, page labels, and other interactive PDF features so you can control how a document appears and behaves in viewers. The module lets you export to disk or to a string and supports importing pages as form XObjects for two-up or four-up layouts. Be aware that PDFs are built in memory and the module contains circular references so you should call save or close in long-running processes to free memory. PNG images with alpha channels are processed slowly unless you install PDF::API2::XS or Image::PNG::Libpng to accelerate them.

Perl::Version::Bumper automates updating Perl source to declare a newer language version by inserting or rewriting a use VERSION line at the top of a file and by cleaning up redundant use feature or use experimental pragmas and removing or replacing compatibility modules when those features become part of the target bundle. It works on raw source strings, PPI::Document objects, or files in place and provides safe variants that try compiling the bumped code and will step down through earlier stable bundles until a version that actually compiles is found. The constructor enforces sensible target versions and only allows increasing an existing declaration, and helper exports provide version formatting and stable version math mainly for internal tooling. Recent changes added support for the v5.042 feature bundle and fixed bump_file handling when given a plain string filename while improving documentation. If you need to modernize many Perl files without breaking feature semantics or leaving stale compatibility shims this module handles the mechanical edits reliably.

NKC::Transform::MARC2RDA is a lightweight Perl class for converting MARC bibliographic records into RDA-oriented output, intended for use in cataloging workflows and data conversion pipelines. It provides a transform() method to apply the conversion and in the latest release now accepts optional parameters to control the transformation, making it easier to integrate into larger Perl-based systems or batch processing scripts. The module is part of the NKC Transform suite developed with support from the National Library of the Czech Republic and is suitable for librarians, metadata specialists, and developers who need automated MARC-to-RDA conversion without diving into low-level details. The project is young but actively maintained, with documentation and tests added in recent updates.

NKC::Transform::MARC2BIBFRAME is a small utility class for converting MARC bibliographic records into BIBFRAME XML using versioned XSLT stylesheets. You create an object with new and can choose the transformation version or supply a custom XSLT file, then call transform to get a BIBFRAME XML string suitable for downstream processing or ingestion. The module wraps XML::LibXML and XML::LibXSLT and exposes a simple version method so you can pick among provided transforms, currently including 2.5.0, 2.9.0, 2.10.0 and the newly added 3.0.0. It is part of the NKC::Transform family, is open source on GitHub, and is handy for libraries and projects that need a straightforward, scriptable MARC-to-BIBFRAME conversion step.

NKC::Transform::BIBFRAME2MARC is a compact Perl utility for converting BIBFRAME bibliographic data into MARC XML by applying packaged XSLT transformations. You create an object, optionally pick a transformation version, and call transform with your BIBFRAME XML to receive MARC XML as a string. The module uses XML::LibXML and XML::LibXSLT under the hood and ships with versioned XSLT files so you can target specific mapping rules. This is useful for library software developers and cataloging workflows that need reliable, scriptable conversions between linked‑data BIBFRAME and legacy MARC formats. Recent releases added newer transformation sets including a 3.0.0 mapping and accompanying tests, and a small packaging fix.

Term::TablePrint is a Perl utility for displaying an array-of-arrays as an interactive, paginated table in a terminal so you can browse rows with a keyboard cursor, search with regular expressions, and expand individual rows to see each column on its own line. You can call it as a simple print_table function or as an object, and it handles paging, automatic column sizing and trimming to fit narrow terminals, right- or left-justifies numbers and text, and offers options for color, column selection, binary-data handling, whitespace squashing, decimal separators, and progress feedback when preparing large tables. Common navigation keys and vi-style shortcuts are supported and you can restrict visible columns or run case-sensitive or insensitive searches. The module expects decoded strings, a matching STDOUT encoding layer and a monospaced terminal, and requires Perl 5.16 or newer. It is a good fit when you want a quick, configurable interactive viewer for tabular data directly from Perl scripts.

Math::GMP_OLOAD is a lightweight compatibility helper that makes Math::GMP objects play nicely with related big-number modules so you can compare and do arithmetic across types like Math::MPFR, Math::GMPq and Math::GMPz without surprising results. It does not implement numeric routines itself but arranges sensible operator overloading so expressions such as comparisons and mixed multiplications return the expected numeric object type and value. The module requires Math::GMP to be installed and will not load without it, and users should note the author tests with Math::GMP 2.11 and Math::MPFR 4.47 or newer. Recent releases are minor maintenance updates with a portability fix for older Perl builds prior to 5.18 and the package is intended as a simple, permissively licensed glue layer rather than a replacement for the underlying math libraries.

mb::JSON is a small, dependency-free JSON encoder/decoder for Perl that correctly handles UTF-8 multibyte strings and runs on older Perls (5.005_03 and later), making it useful where JSON::PP or JSON::XS are not available. It provides decode/parse to turn JSON text into Perl data and encode to produce UTF-8 JSON text from Perl structures, with hash keys sorted for deterministic output. The module supplies singleton boolean objects mb::JSON::true and mb::JSON::false so JSON true/false round-trip unambiguously, and decoded booleans are returned as mb::JSON::Boolean objects that behave like 1 or 0 in numeric and boolean contexts. Limitations include no support for UTF-16 surrogate pairs in \\uXXXX escapes, no detection of circular references during encoding, and non-array/hash references being stringified rather than raising errors. Version 0.04 notably added encode(), the Boolean type, and made decode() the canonical name while retaining parse() for compatibility.

IPC::Manager is a Perl library that makes it easy for multiple programs running on the same machine to exchange structured messages without a central broker. It gives you a simple spawn/connect API so one process can create a data store and hand out a short connection string that any local process can use to send and receive messages, and it supports pluggable serializers and a choice of transport backends so you can pick file-based directories, atomic pipes, Unix sockets, or DB-backed stores like SQLite, MySQL, MariaDB, and PostgreSQL. Messages are delivered as IPC::Manager::Message objects and the system supports both temporary guarded stores that clean themselves up and persistent stores for long-lived services. If you need lightweight, decentralized IPC for local scripts, daemons, or small services this module provides a practical, cross-platform way to pass structured payloads between processes. Recent updates have improved UnixSocket reliability on BSD systems and added IO::Select support to better handle I/O capabilities.

This is a placeholder module created solely to allow the distribution to be indexed by CPAN. It contains no functional API and is not intended for runtime use or installation on end-user systems under normal circumstances. If you are a CPAN author or packager who needs a stub to make a distribution discoverable, this is the kind of minimal module you would include; otherwise it is not relevant for application developers or library consumers.

Chess4p is a Perl library that provides the basic building blocks for chess software, including legal move generation, perft performance testing, UCI move input/output, FEN parsing and ASCII board display, with Board and Move objects that let you push and pop moves to explore positions. It is aimed at developers writing engines, analysis tools, or integrations rather than end users, and it runs on 64-bit systems only. Planned additions include SAN move input/output and PGN parsing, and a recent minor change swapped Test2::V1 for Test::More to improve compatibility with CPAN testers.

Sekhmet is a compact, high-performance Perl extension that generates ULIDs, which are timestamp-first, lexicographically sortable unique identifiers, by binding to Horus C primitives for fast Crockford base32 encoding, cryptographically secure randomness and precise millisecond timestamps. It provides simple functions to create string and 16-byte binary ULIDs, monotonic variants that preserve ordering when many IDs are made in the same millisecond, utilities to extract the embedded timestamp in seconds or milliseconds, validation and comparison helpers, and conversion to and from UUID v7 for interoperability. The initial 0.01 release delivers these core features with an emphasis on raw speed and minimal Perl-side overhead, making Sekhmet a good choice when you need sortable, collision-resistant identifiers at high throughput.

Apophis is a compact, high-performance content-addressable storage library for Perl that produces deterministic UUID v5 identifiers for blob content using the Horus RFC 9562 library. It guarantees identical content maps to the same UUID while different namespaces yield distinct UUIDs, making deduplication and logical partitioning straightforward. Objects are stored in a two-level hex-sharded directory layout for scalable filesystem performance, writes are atomic via temporary files and rename, and file identification is streamed in fixed-size chunks so large files use constant memory. The API is minimal and pragmatic: identify content or files, store and fetch by UUID, verify integrity, remove items, and run bulk operations like store_many and find_missing, with optional per-object metadata. The core is implemented in C with an XS Perl wrapper so you get C-level speed from simple Perl calls, making Apophis a good fit when you need deterministic, namespace-aware CAS with efficient on-disk layout and atomic semantics.

GnuPG::Interface is an object oriented Perl wrapper for calling the GnuPG command line tool so your scripts can encrypt, decrypt, sign, verify, and enumerate keys programmatically. It gives you a GnuPG::Interface object with a GnuPG::Options object and a GnuPG::Handles object so you can attach Perl filehandles for stdin, stdout, stderr, status, logger and passphrase and use methods like encrypt, decrypt, sign, list_public_keys or the generic wrap_call to invoke arbitrary gpg commands. The module uses Moo to generate accessors so list-style options get useful push and pop helpers and it deliberately exposes bidirectional interprocess communication rather than hiding it so you retain control over filehandles and passphrase handling or let gpg-agent/pinentry manage secret key prompts. Supported GnuPG versions are 1.4.x, 2.2.x and 2.4.x and there are convenience features for passing a passphrase from Perl or receiving status output. If you need to process large streams be aware the author notes potential buffering issues with very large data and some parsing edge cases for older OpenPGP v3 keys, but for most scripting tasks this module gives a clean, tested way to integrate GnuPG into Perl applications.

Slug is a compact, high-performance XS Perl module that converts UTF-8 text into SEO-friendly, URL-safe slugs for use in links, file names, or identifiers. It provides a simple slug() call that transliterates Unicode to ASCII, lowercases and replaces non-alphanumeric characters with a separator, a slug_ascii() helper that only transliterates while preserving spaces and case, and slug_custom() for full control over separator, max_length, lowercase, transliteration and trimming behavior. The module ships a broad Unicode transliteration table covering Latin, Greek, Cyrillic, Vietnamese, symbols, ligatures and fullwidth forms and uses Perl 5.14+ custom ops for zero-overhead dispatch when available, making common slug tasks very fast. A tiny C core is exposed via include_dir() so other projects can reuse the implementation. This is the initial 0.01 release from 2026-03-26 and is released under the same terms as Perl.