CPANscan

Stats::LikeR brings a broad collection of R-like statistics and tidy-data tools to Perl, packaged as an XS-backed library for much faster numeric work. It understands multiple data-frame shapes (array-of-arrays, array-of-hashes, hash-of-arrays, hash-of-hashes) and provides familiar operations such as aggregation/group_by, merge/concat/rbind, pivot_table/melt, reshaping helpers, many statistical tests (t, ANOVA, chi-square, Fisher, Wilcoxon, Kruskal, KS, etc.), regression and GLM, PCA, interpolation and binning, and utilities like colnames/rownames/vals/value_counts. It also reads and writes delimited files and XLSX workbooks, supports in-place column transforms and column-wise assignment, and aims to match R/pandas behavior where useful while keeping Perl idioms. The module is actively maintained with many recent fixes and speedups, notably moving the numeric interpolate core into XS for large speed gains and a 0.26 fix for a long-double issue, so it is a good choice if you want R-style data manipulation and statistics inside Perl with production-oriented performance and robust error handling. Be aware a few R conveniences are intentionally limited here, for example its ANOVA routines produce Type-I (sequential) tables and predict has constraints around factor-level reconstruction, which the author documents.

PDF::Make is a Perl toolkit for creating, editing, and reading PDF files. It offers a recommended high-level, chainable Builder API that handles layout, page management, word wrap, font metrics, images, and common document tasks for quick report and form generation. For users who need full control it also provides a low-level XS API that maps directly to PDF concepts and content streams. The distribution includes parsers and extractors for reading existing PDFs, font and image support, interactive features like links and AcroForms, security features including encryption and digital signatures, and utilities such as attachments, watermarks, redaction, and linearization. It has minimal runtime dependencies beyond Object::Proto and is a good fit for Perl projects that need reliable programmatic PDF manipulation.

Hash::Typed provides ordered, typed hash containers for Perl that let you declare what keys a hash must have and what types their values must be. You can create a Hash::Typed object or tie a hash to it, enable strict and required-key checks, use type constraints from Types::Standard or supply custom validator coderefs, and even nest Hash::Typed instances for structured data. Assignments or instantiations that do not satisfy the declared constraints raise errors, which helps with input validation, configuration handling, and enforcing clearer data contracts. Recent updates include improved test coverage to 100 percent and a minor packaging cleanup.

HTTP::XSHeaders is a drop-in, C-backed replacement for the Perl HTTP header libraries HTTP::Headers and HTTP::Headers::Fast that gives existing Perl code a big speed boost simply by loading the module. It preserves the familiar public API so you can keep using the same methods for getting, setting, scanning and serializing headers while benefiting from a lightweight, thread-safe native implementation. The module intentionally normalizes header names to standard casing, converts underscores to hyphens, and makes a few small compatibility changes such as not supporting leading-colon literal names or the old $TRANSLATE_UNDERSCORE behavior, and it always loads Storable but performs cloning at the C level. Benchmarks included with the distribution show substantial improvements across common operations, making this a good choice when you need lower-overhead HTTP header handling. Recent releases fixed a heap-buffer-overflow issue and marked the project stable, and the most recent patch added an explicit dependency on HTTP::Headers and a fix for older Perl package declarations.

ExtUtils::ParseXS is the tool that turns Perl XS files into the C or C++ "glue" code needed for Perl to call native functions, applying typemaps to map Perl values to C types and emitting useful runtime checks and #line directives for easier debugging. It is the backend used by xsubpp and is what you reach for when you are writing or maintaining Perl extension modules that include C or C++ code, or when you need to embed custom typemaps to control argument and return value conversions. The module supports modern needs such as version checks, prototype generation, exception stubs and C++ linkage, and it offers both an OO and a legacy functional interface so it can be used programmatically or as part of the normal XS build flow. ExtUtils::ParseXS is actively maintained and has seen recent internal refactoring to an Abstract Syntax Tree for more robust parsing, clearer error messages and improved typemap handling including more flexible support for functions like length().

Kwiki::Comments is a simple Kwiki plugin that adds per-page comment forms so visitors can leave feedback in the style of Slash or Movable Type comments. To enable it you add "Kwiki::Comments" to your plugins file, run kwiki -update, and insert the tag {comments} on any page where you want a form to appear. It is useful for wikis that lock page editing but still want public input, and it is aimed at site maintainers who want lightweight commenting without a separate system. Note that the module currently requires DBD::SQLite as its database backend.

GraphQL::Houtou is an XS-backed GraphQL parser and high-performance execution toolkit for Perl that gives you a canonical Perl AST and a native VM for running compiled query programs. It is designed for real web apps and makes batching simple with a bundled DataLoader and an on_stall hook that collapses N+1 database lookups while still returning a synchronous response to callers. You can render responses directly as UTF-8 JSON bytes inside the XS lane to avoid building Perl data structures, expose a one-line PSGI endpoint with optional GraphiQL, and create persisted artifacts for maximum throughput either as fixed native bundles or as compiled programs for variable-bearing queries. Runtimes can be built for async promise-based resolvers or for a strict synchronous fast lane and include configurable cost limits and program caching for production safety. The module focuses on throughput and efficiency and reports large benchmark gains over pure Perl implementations. Current limitations in the 0.01 profile include no subscription execution or streaming transports, only POST for the PSGI adapter, recognition of only Promise::XS promises, fixed native bundles not supporting GraphQL variables, and no support for Perl ithreads, so use process-based concurrency for parallelism.

Terse::Runtime is the runtime component for the Terse project that provides the support code and environment needed to run Terse-based code under a standard Perl interpreter. It is intended to be installed alongside the main Terse distribution to satisfy runtime dependencies and to supply the lightweight helpers and initialization routines that Terse-generated modules expect. If you work with Terse or need to run code produced by the Terse toolchain this module is relevant, and you can find usage docs via perldoc Terse and report issues through the CPAN RT page; the module is distributed under the Artistic License 2.0.

Terse::Config is a lightweight configuration plugin for the Terse framework that gives your application a concise way to load and read settings. You typically subclass a backend such as Terse::Plugin::Config::YAML to load YAML files and then access values either with a find method that accepts path strings or by chained accessors on the data object, for example $terse->plugin('config')->data->path->to->key. It is intended for Perl developers building Terse-based applications who want a small, convention-driven config layer. The module is available on CPAN, maintained by LNATION, and distributed under the Artistic License 2.0. Report bugs through the CPAN RT tracker.

Terse::Plugin::UA is a small plugin for the Terse framework that exposes LWP::UserAgent style HTTP functionality to your Terse applications, letting models and controllers make simple GET and POST calls via a minimal API. It integrates with Terse config so you can supply paths from your configuration and pass parameters directly, for example calling $t->plugin('ua')->get or ->post with path and params, which keeps HTTP request logic tidy and consistent across your app. The module is lightweight and aimed at straightforward HTTP interactions inside Terse projects rather than advanced HTTP client features. The recent 0.04 release removed PAX headers.

Terse::Plugin::Glitch is a small plugin for the Terse framework that centralizes and standardizes error responses and logging by loading a configurable set of named responses from an external file (YAML or other supported formats). You add it to your Terse app or subclass it, point it at a glitch_config file and then call methods like call('unauthenticated') to obtain a response hash or logError to record a problem, which makes it easy to keep consistent, configurable error payloads across handlers. It is useful if you want a simple, declarative way to manage and reuse response templates in a Terse-based service. The recent 0.05 release simply removed PAX headers.

Terse::Plugin::DBI is a tiny adapter that brings Perl's DBI database access into the Terse web framework so your controllers and models can prepare and execute SQL directly. You subclass the plugin and supply a connect_info method that returns the DSN, username, and password, and then call $t->plugin('dbi')->prepare(...) from your code to get statement handles and run queries. This module is intentionally lightweight and is ideal when you want straightforward DBI access rather than a full ORM or heavy abstraction. It is released as version 0.05 under the Artistic License 2.0 and was recently updated to remove PAX headers.

Terse::Plugin::CHI is a lightweight plugin for the Terse web framework that adds simple response caching by leveraging the CHI caching system. It provides an easy, controller-level API so you can check for a cached response with plugin('cache')->get($t) and store the current response with plugin('cache')->set($t), letting handlers short-circuit repeat work and reduce database or compute overhead. The module is intentionally minimal and acts as a thin bridge to CHI backends, so it is most useful when you already use Terse and want a quick way to cache whole responses without building a custom caching layer. The most recent release only made a packaging cleanup to remove PAX headers.

Terse::Es is a lightweight Perl helper that makes it easy to hook an application up to Elasticsearch by providing simple base plugin and model classes to subclass. You supply connection info in a plugin and declare an index plus column metadata in a model, including display labels, field aliases and basic table or sort hints, and then call straightforward methods such as search to run queries and get results back in a usable form. The module is aimed at projects that want a terse, opinionated glue layer between their app and Elasticsearch rather than a full blown client library. The current 0.04 release only contains a packaging fix that removed PAX headers.

Terse::Static is a small module for the Terse Perl web framework that makes it easy to serve static assets like JavaScript, CSS, images, and HTML alongside your dynamic routes. It integrates with Terse controllers and views so you can map URLs to resources and declare content types using the same method attributes you already use, and it includes a memory-backed view for embedding assets plus a delayed static controller for on-demand delivery. If you use Terse and want a simple, framework-native way to expose static files without wiring up a separate server, this module provides a tidy, low-friction solution.

Terse::Headers is a lightweight plugin for the Terse Perl web framework that provides a simple way to manage HTTP response headers from your application. You attach an instance to your Terse app and then call its set method with the current request context to add or change headers, which makes it handy for middleware, authentication hooks, or any place you need to tweak response headers without boilerplate. The module is small and focused, documented via perldoc and its CPAN page, and the author accepts bug reports through CPAN's RT tracker.

Terse::View::TT is a lightweight adapter that lets Terse web applications render Template Toolkit templates as views. You create a view class that inherits from Terse::View::TT, configure Template Toolkit options such as a wrapper template, place your templates in the application source tree, and mark controller actions with view(tt) so template variables set on the response are available to your pages. The module fits into a PSGI/Plack deployment, so it works with common servers like Starman, and it is a simple way to use Template Toolkit layouts and template features within the Terse controller/view conventions.

Terse is a compact Perl web framework for quickly building JSON-style APIs on Plack, offering a simple, DSL-like way to define endpoints, manage authentication and sessions, and shape the JSON you return. It wraps request handling, parameter parsing and response serialization so you can set response fields directly, and it adds built-in logging, error helpers, redirects and pretty-printing. Terse also supports delayed responses for non-blocking servers and long-polling, has WebSocket handler hooks for realtime use, and provides plugin, model and view support so you can reuse code across apps. You can run it as a PSGI app or mount your own application object and supply custom auth/login/logout routines, making it a pragmatic choice when you want a lightweight, Plack-native toolkit for building RESTful JSON endpoints and simple realtime features in Perl.

CPANSA::DB is a tiny helper module that packages the CPAN Security Advisory reports as a ready-to-use Perl data structure so tools like CPAN::Audit can load and inspect advisory data easily. Its single db() subroutine returns a hashref containing the advisory records and the same data is also provided as a JSON file for non-Perl consumers. Releases are published on GitHub and include a GPG signature and GitHub attestations so you can verify the archive came from the official repository before trusting the data. If you need a simple, verifiable source of CPAN security advisories for auditing, scanning, or integration into your tooling, this module gives you that data in a straightforward form.

mb::JSON is a small, dependency-free JSON encoder and decoder for Perl 5.005_03 and later that is optimized for environments where more modern JSON modules are unavailable and that preserves UTF-8 multibyte text correctly. It exposes simple decode/parse and encode/stringify functions, provides singleton mb::JSON::true and mb::JSON::false objects to represent JSON booleans, and handles common JSON features like skipping a leading UTF-8 byte order mark, combining UTF-16 surrogate pairs into proper UTF-8, and returning Perl arrays and hashes for JSON arrays and objects. The module is configurable via $mb::JSON::MAX_DEPTH to protect against deep nesting and $mb::JSON::STRICT to enable UTF-8 validation and raw control character checks, and it reports circular references and refuses to encode non-finite numbers like Inf and NaN to avoid silent surprises. The recent 0.07 release made decoding linear-time on large inputs, tightened whitespace handling to match RFC 8259, added surrogate-pair support and better error diagnostics, and otherwise improves robustness while keeping the API intentionally simple and portable.

HTTP::Cookies is a simple cookie jar you can attach to Perl's LWP::UserAgent to record cookies sent by servers, apply the right Cookie headers to requests, and manage cookies programmatically, including adding, clearing, scanning, and saving or loading the jar to disk. It understands legacy Set-Cookie and Set-Cookie2 formats and supports RFC 2965 style cookies, and a Netscape-compatible save format is available via a subclass if you need browser-compatible files. The module gives you control over temporary versus persistent cookies, discard behavior, and expiry handling, but it does not implement public suffix checks from newer standards so it may allow cross-site tracking across top level domains. Recent releases fixed cookie lifetime handling so Max-Age is now honored when extracting cookies and Max-Age correctly takes precedence over Expires.

Sah::SchemaBundle::UUID is a small collection of Sah-compatible validation schemas for UUID/GUID values designed to plug into Data::Sah or any Sah-based validation workflow. The bundle currently offers a single schema, uuid::hexdigit, which validates UUIDs expressed as plain sequences of hexadecimal digits, making it useful for validating ID strings in APIs, configuration files, or data models that require simple, well-formed UUIDs. The distribution is intentionally minimal and focused, easy to include in existing Sah schema sets, and this is the initial 0.001 release with source on GitHub and a MetaCPAN page for more information.

SDL3 is a Perl wrapper around the SDL3 cross-platform multimedia C library that brings low-level access to audio, input devices, windows, 2D/3D rendering, timers, threading, file dialogs and other OS services into Perl programs. The module exposes SDL's extensive API through selectable import tags like :video, :audio, :render, :events, :main or :all so you can pull in only the subsystems you need and it supports SDL3's callback-based App system for integrating the main loop. If you want to write games, multimedia tools, device-aware utilities or cross-platform GUI code in Perl while leveraging SDL features such as async I/O, gamepad and joystick support, Vulkan and Metal interop, clipboard and system tray access, this module is a practical choice. Examples and demos are included in the distribution and on the project GitHub, and the code is released under the Artistic License 2.0.

Module::Pluggable makes it trivial to give your Perl module a plugin system by exporting a method (default name plugins) that discovers modules under one or more namespaces or directories, optionally requiring or instantiating them and returning either class names or objects. You configure which namespaces or dirs to search, filter results with only or except, control instantiation or plain require, limit nesting depth, choose result ordering, and attach hooks to veto or handle require and instantiate events. The search runs on each call so new plugins can be picked up at runtime but you can cache results yourself for better performance when dynamic discovery is not needed. It respects blib and @INC hooks so it works well in test environments and with packers, and it will use Module::Runtime when available for safer loading. If you want a small, flexible way to add pluggable handlers to an application without a big framework, Module::Pluggable is a practical and well proven choice.

LibUI is a Perl binding to the libui-ng native GUI library that lets you build simple, cross‑platform desktop interfaces using familiar widgets like windows, buttons, boxes, menus, dialogs, tables, drawing areas, text layouts and more. It exposes a straightforward functional API with helpers and some OO wrappers such as a chainable Matrix object for draw transforms, and it also converts lower‑level C patterns into Perl‑friendly forms so things like date/time, font descriptors and out‑parameters return native Perl structures. The module is aimed at developers who want lightweight native look and feel without wrestling with platform‑specific toolkits and it includes timers, threading hooks, file and message dialogs, rich text attributes and a full table/model system for data views. The recent 1.0.0 release brings the complete libui-ng widget set plus a large collection of example programs from calculators and clocks to a tabbed notepad and table demo, and it improves area handler callbacks so drawing, mouse and key events are delivered as convenient Perl data structures. Note that LibUI requires a libui runtime (provided via Alien::libui) and is best for small to medium GUI tasks where a simple native interface is desirable.

DateTime::Format::Genealogy is a small Perl utility that turns genealogy-style date strings, especially GEDCOM exports, into DateTime objects so you can work with dates programmatically. It understands common nonstandard month names and can parse exact dates, GEDCOM calendar escapes like Julian, Hebrew and French Republican when the appropriate calendar modules are installed, and it returns date ranges as a pair of DateTime objects when the input expresses a range. You can control behavior with quiet and strict flags to suppress warnings or enforce three-letter GEDCOM month abbreviations, and the parser deliberately rejects approximations, year-only strings and dates before AD 100 to avoid misleading results. Recent maintenance releases fixed a number of parsing and cloning bugs, added input sanitization in diagnostic messages and a cache size guard to improve security and robustness, and also improved performance by caching failed parses. If you need to normalize or convert genealogical dates into standard DateTime objects for reporting, searching or downstream processing this module is a practical choice, but be aware that some calendar conversions require optional modules and that very old pre-100 AD dates are intentionally not supported.

Net::BitTorrent is a full-featured BitTorrent client library for Modern Perl (requires v5.40+) that you can embed in scripts or applications to manage swarms, peers, storage, and discovery without committing to a specific event loop. It is designed around loop-agnostic integration, first-class BitTorrent v2 support (Merkle trees and SHA-256 infohashes), and strong security defaults including DHT hardening and protocol encryption, and it exposes a straightforward API to add torrents from .torrent files, magnet URIs, or infohashes, to register event callbacks, to tick or wait a main loop, and to persist and restore session state. The module provides high-level objects for the client, individual torrents, peers, and disk storage, plus DHT get/put/scrape helpers, global rate limiting, and a background hashing queue to keep verification off the hot path. Recent 2.1.1 tweaks make client authoring nicer by adding a fast torrents_hash lookup by infohash, a magnet_uri builder for constructing links, new per-torrent and peer metrics, and a lower-cost tick loop that reduces CPU spikes and improves UI responsiveness, so this is a good choice if you need a modern, secure, and extensible BitTorrent engine in Perl.

App::zipdetails is a tiny Perl package that exposes a tool for inspecting the internal structure of ZIP archives. The module itself is a stub and the actual functionality is provided by the companion script bin/zipdetails, which prints archive entries, headers and other structural metadata so you can examine what is inside a ZIP without extracting it. It is handy for developers and administrators who need to audit or troubleshoot ZIP files. The author is Paul Marquess and the code is distributed under the same terms as Perl.

Affix is a high performance Foreign Function Interface for Perl that lets you call native libraries and languages like C, Rust, Zig, Go and Fortran directly from Perl without writing XS or compiling glue code. It uses a JIT trampoline engine to marshal arguments and returns at near native speed and provides a rich C-like type system including primitives, structs, unions, enums, SIMD vectors and pointers. Affix gives live, zero copy views of C aggregates so you can read and write C memory through normal Perl hashes and arrays, allocate and manage heap memory with malloc/calloc/realloc/strdup, pin Perl scalars to C globals for two way binding, and attach custom destructors for owned buffers. You can load and locate libraries across platforms, bind symbols as named subs or anonymous wrappers, pass Perl coderefs as callbacks, call variadic functions with explicit coercions, and introspect sizes and offsets with sizeof, alignof and offsetof while using built in debugging helpers like errno dualvars and memory dumps. The recent v1.1.0 release introduces a revamped V2 pin system backed by Perl magic VTables to eliminate tied‑variable overhead and boost zero copy performance, adds a Const[...] wrapper to enforce read only C memory from Perl, and improves Affix::Wrap header parsing and type handling.

Plerd is a minimalist static-blog tool that turns Markdown files kept in a Dropbox-synced directory into a ready-to-publish website, making it easy to write posts in your editor and have HTML, tag indexes, recent-post lists, and feeds generated for you. You configure a few basics like the blog path, title, base URL, and author info and then Plerd uses templates to render pages, supports a default social image and Twitter handle, and keeps an internal index so it can republish a single changed file quickly or rebuild everything when post metadata changes. If you want a simple, file-driven workflow for a small blog without a database or heavy CMS, Plerd provides a clean, lightweight solution.