CPANscan

Crypt::Image is a Perl module for basic steganography that hides short text messages inside a PNG image using a separate key image. You construct it with a key PNG, call encrypt to produce a new PNG with the message scattered across pixels and padded with randomized noise so repeated encryptions look different, and call decrypt with the same key image to recover the text. The module encodes UTF character codes across the R, G and B channels and adjusts pixel values to blend data into the image, so it is best suited for short secret messages rather than large payloads. It currently supports only PNG files and the maximum message length depends on the image dimensions.

Math::Histo is a high-performance Perl XS wrapper around the libhisto C library that gives you fast, memory-safe 1D and 2D histogramming, streaming quantile sketches (DDSketch), online Welford moments, and non-linear curve fitting via Levenberg-Marquardt. It supports uniform and variable-width bins, weighted fills with optional sum-of-weights-squared bookkeeping, and very fast batch ingestion from Perl arrays or zero-copy packed 64-bit float buffers to exploit SIMD acceleration. The module exposes a rich set of statistical tools and convenience features including mean, variance, median and quantiles, mode and peak properties, skewness and kurtosis, rebinning and arithmetic operators, two-sample distances and hypothesis tests, and model fitting, plus compact binary and JSON serialization for storage or transport. If you need production-grade histogramming or summary statistics in Perl with C-level throughput and interoperability with native numeric buffers, Math::Histo is a solid choice.

SPVM::Errno exposes the native C errno values and messages to SPVM programs so you can read and set the process errno, map numeric error codes to human messages with strerror, and fetch numeric constants for over a hundred POSIX and Windows (Winsock) error codes. Each error name is provided as a static accessor that returns the platform’s native integer, and if a particular constant is not defined on the host the accessor raises an Error::NotSupported exception. The module is useful whenever your code interfaces with native C or OS calls and needs reliable, platform-correct error codes. Recent releases improved portability and robustness by adding MSVC/Windows support and a strict cross‑platform test suite that validates all Errno and WSA constants against native OS values, and the module now requires a recent SPVM runtime.

SPVM::Compress::Raw::Zlib is a low level SPVM binding to the zlib compression library that gives SPVM programs direct access to zlib functionality. It exposes Deflate and Inflate classes plus compression constants, and includes convenient gzip and gunzip methods that compress or decompress buffers while automatically handling options like window bits and output appending. Choose this module when you need efficient, low overhead control over compression streams or want to integrate standard zlib compression into SPVM code. The project is on GitHub and is distributed under the MIT license.

SPVM::Digest::SHA is a lightweight SPVM port of Perl's Digest::SHA that gives you standard SHA hashing and HMACs for use in SPVM programs. It exposes convenient functional calls like sha1/sha256/sha512 and their _hex and _base64 variants, plus an object API for incremental hashing with new, add, digest, hexdigest, b64digest and clone. The module covers SHA-1, SHA-224, SHA-256, SHA-384, SHA-512 and the SHA-512/224 and /256 variants and provides HMAC versions of each, so it is useful for integrity checks, signatures and authentication in SPVM code. Recent releases improved portability and native-type usage, added MSVC support, and bumped the required SPVM version to ensure modern toolchain compatibility.

SPVM::Digest::MD5 is a straightforward SPVM port of Perl's Digest::MD5 that lets you compute MD5 message digests either with simple class methods or via an object-oriented interface. You can call md5 to get the raw 16-byte binary digest or md5_hex to get a 32-character lowercase hexadecimal string, or create a Digest::MD5 object with new, feed data with add, and retrieve the result with digest or hexdigest. The methods expect defined input and will raise exceptions on invalid arguments, and note that older convenience methods that returned base64 (md5_base64 / b64digest) were removed so use a base64 encoder if you need that form. Recent updates modernize build/config handling, raise the minimum SPVM requirement, and add MSVC support.

Hyperman is a production-focused PSGI web server for Perl that combines a prefork supervisor with a per-worker XS event loop to serve synchronous and asynchronous apps with low overhead. Handlers can return Hyperman::Future objects so you can await timers or IO without blocking the worker, and the server exposes timers, readiness watchers, and a C ABI so other XS modules can integrate directly. It includes built-in features you expect from a modern server: fast C-side access logging, optional gzip compression with tunable level and thresholds, TLS with SNI and client certs plus kernel TLS when available, HTTP/2 support, multiple listeners and redirect helpers, and a safe spill-to-temp-file strategy for large request bodies. For pool-wide coordination it provides a shared memory pub/sub message bus and a fork-shared denylist and fixed-window rate limiter so limits and blocks are consistent across workers. The implementation is intentionally XS-heavy for performance and exposes hooks for per-worker startup and in-place TLS reloads. If you need a high-throughput PSGI server with async-friendly primitives, per-worker isolation, and low-latency inter-worker messaging, Hyperman is highly relevant; note that some backends such as io_uring have platform tradeoffs and compression costs CPU so they are opt-in or conservative by default.

CXC::Gnuplot is a Perl library that models Gnuplot plotting constructs as classes so you can build and manipulate plot definitions in code instead of concatenating command strings. It does not run Gnuplot or produce images itself but offers a versioned API (currently V1) to represent commands, styles, axes and data references that you can render later with a tool like Gnuplot::Builder or emit as a gnuplot script. This is useful when you need programmatic, reusable or testable representations of complex plot configurations. The module is meant to be used alongside other tools and is not useful by itself. Source is on Codeberg and the package is released under the GPLv3 license.

Net::IDN::Encode converts Internationalized Domain Names between Unicode and ASCII (Punycode) so you can safely use non‑ASCII hostnames and the domain parts of email addresses in applications. It exposes simple functions such as domain_to_ascii, domain_to_unicode, to_ascii, to_unicode, email_to_ascii and email_to_unicode to encode and decode labels and whole hostnames while handling common variants of dots and at signs. The module implements the current IDNA/UTS46 rules and offers options to enforce STD3 ASCII rules, enable transitional processing for legacy behavior, or allow Unicode code points that are unassigned in the Perl you are running. It expects properly encoded Perl Unicode strings so very new characters may be rejected on older Perls unless you opt into AllowUnassigned. The local part of email addresses is not internationalized by this module. Recent releases include compatibility fixes and maintainer updates to keep the module working with modern Perl and Unicode versions.

Test::Simple is a tiny, beginner-friendly testing tool for Perl that gives you the essentials to write TAP-compatible tests. You declare how many tests you plan to run with use Test::Simple tests => N or finish with done_testing(), and use ok(EXPR, NAME) to print numbered "ok" or "not ok" lines that Test::Harness and other tools understand. It intentionally provides only the basics so you can get tests written quickly and reliably, and it is fully forward compatible with Test::More if you later need richer assertions and helpers. Exit codes reflect success, failures, or abnormal termination so they work well in build systems. The module is actively maintained and recent updates improved subtest line-number reporting to match modern Perl core behavior and integrated newer Test2-related improvements.

PAGI::Server is a reference Perl HTTP server that implements the PAGI application protocol and provides HTTP/1.1, WebSocket, and Server-Sent Events with experimental HTTP/2 support, making it a good choice when you need a canonical, spec-compliant server for development, testing, or as a backend behind a reverse proxy. It focuses on clarity and correctness rather than microbenchmarks and includes production-oriented features such as optional TLS, Unix domain socket support, multi-listener and systemd socket activation, a prefork worker model with hot restart, per-connection limits and timeouts, streaming file responses, and IO::Async integration for embedding in an event loop. Experimental features and tunables are well documented and most work out of the box, but HTTP/2, Unix socket and multi-listener modes are still labeled experimental and Windows is not supported. The recent 0.002007 release tightens PAGI conformance by advertising PAGI 0.4, makes outbound event validation and strict send sequencing mandatory, and delivers a number of important HTTP/2 fixes and improvements including trailers support, safer per-stream backpressure and more reliable WebSocket-over-HTTP/2 framing, plus a raised nghttp2 dependency floor and the removal of the deprecated lifespan_mode 'off', so be sure to read the notes before enabling experimental features.

Text::Password::Pronounceable is a small Perl module that creates human-friendly, pronounceable passwords by using English digraph statistics (based on work by D. Edwards). You can call it directly as a class method or construct an object with a fixed length or a minimum and maximum length and then generate passwords on demand, which makes it handy for producing memorable credentials for users, temporary tokens, or test data. It returns an empty string and emits a Carp warning on failure. The module is freely redistributable under the same terms as Perl.

Perl::Critic::Grape is a small collection of extra Perl::Critic policies that help teams catch and enforce clearer, more consistent Perl style choices during static analysis. It adds rules to require parentheses when calling builtins, forbid inline do blocks, discourage manual reference-type checks, insist on explicit sigils to signal variable types rather than relying on arrow dereferencing for methods, promote using array and hash slices for lookup sequences, and replace the topic iterator with named loop variables. If you already use Perl::Critic and want stricter, readability-focused checks this module plugs in easily. The latest release adds the RequireSlices policy to encourage slice-based lookups.

Hash::SharedMem provides a fast, memory-mapped, on-host key/value store that multiple Perl processes and threads can share for mutable data. It exposes a handle-based API to open a shared hash stored in a directory, read and write octet-string keys and values, perform atomic single-key operations like compare-and-set and get-and-set, take read-only snapshots, and enumerate keys or the whole content. The module is designed for datasets that fit in RAM or a memory-backed filesystem so access is low-latency, and complex Perl objects can be stored by serializing them first. Performance will suffer if the data mostly lives on disk and the module does not guarantee durability across an OS crash. The documentation also explains file-permission and ownership semantics, non-atomic creation edge cases, and provides maintenance operations to tidy storage and reduce resource use. Use this when you need efficient interprocess shared state on one machine and can accept the in-memory performance model and the stated durability and creation caveats.

File::Raw::Archive is a streaming, plugin-driven Perl toolkit for reading and writing archive containers with a focus on real-world tar usage. It ships with a tar plugin that understands ustar, GNU @LongLink and PAX extended headers, auto-detects or writes gzip compression, and provides simple helpers to open and iterate entries, list metadata snapshots, extract single files or whole archives, and build tarballs with per-entry metadata. The API offers both object methods and importable convenience functions and can be extended with sister plugins for zip, cpio or ar formats. It supports safe extraction that rejects path traversal by default, optional round-robin parallel extraction via forked workers on POSIX systems, PAX global metadata and xattr round-trip where the platform supports it, and configurable tar emission modes (auto, pax, gnu, ustar). The recent 0.03 release fixes loading on older Perls and Windows build issues, makes extraction tolerant when the destination filesystem cannot hold extended attributes, and now requires File::Raw 0.15 for matching export fixes. If you need a practical, extensible archive reader/writer that handles the tar dialects you actually encounter and can scale from single-file extracts to parallel extraction, this module is worth a look.

Punk::OAuth2 provides client-side OAuth2 and OpenID Connect support for Punk web applications, letting you add "Log in with" flows for Google, GitHub, or any OIDC provider. It implements the authorization code flow with PKCE, signed state parameters, and id_token verification via Crypt::JWS so authentication is secure and tokens are validated. The real behavior and helpers are exposed through Punk::Plugin::OAuth2, while this distribution module serves as the version anchor and documentation entry point. Use it to plug OAuth2 login endpoints into a Punk app and configure providers with client id, secret, scopes, and callback settings.

File::Raw::JSON is a fast JSON and JSONL plugin for File::Raw that registers "json" and "jsonl" handlers so you can slurp, spew, or stream NDJSON with one syscall path into a high-performance yyjson codec. It also exports direct in-memory functions file_json_decode and file_json_encode when you just want to convert bytes to Perl structures and back without touching the filesystem. The "json" mode handles single-document files and "jsonl" streams records via a brace‑balancing parser so pretty‑printed or multi‑line records and multiple records on one line are all handled correctly while keeping memory bounded. You get familiar encoding and decoding options such as pretty, indent, sort_keys/canonical, relaxed parsing, ordered hashes to preserve key insertion order, and configurable boolean handling. The dist also exposes a simple C ABI for XS consumers that want to call the codec from C with no per-call Perl dispatch. Recent fixes improved large integer handling on 32‑bit Perl builds and the release added the public C ABI while continuing to ship the bundled MIT‑licensed yyjson library.

File::Raw is a performance-focused Perl toolkit for file I/O that uses direct system calls and techniques like preallocated buffers and memory mapping to read, write and iterate files much faster than standard PerlIO. It exposes convenient helpers such as slurp/spew, append, atomic_spew, mmap access, efficient line streaming and iterators, and a stat() call that returns many attributes in a single syscall with an internal cache to reduce filesystem hits. The module includes cross-platform optimizations for copy/move operations and lets you register plugins to decode or encode file content (for example gzip or CSV) and to add per-record transforms, with support for plugin chains when slurping and writing; note that chained plugins can be eager (they slurp the file) and true stream-phase plugins must be implemented in C. If you handle large files, need zero-copy reads or many metadata queries, or want an extensible, low-level file API for high-throughput tasks, File::Raw is a very relevant choice.

Tie::OrderedHash is a drop‑in, Tie::IxHash‑compatible implementation of insertion‑ordered hashes for Perl that also exposes a public C API so XS code can read and write the underlying structure without the overhead of tie dispatch. You can use it as a tied hash or create the implementation object directly and call familiar methods like Push, Pop, Shift, Unshift, Keys, Values, Length, Clear or construct it with an initial list, and it preserves key positions when values are updated and iterates in insertion order. Its internal layout matches Tie::IxHash so migrating code that inspected internals is straightforward. Pure Perl use yields a modest speedup over Tie::IxHash because tie dispatch still applies, but the real benefit comes from the provided C header and functions which let downstream XS modules manipulate the ordered hash efficiently and support concurrent C-level iteration.

Perlanet is a Perl library for building "planet" style sites that aggregate RSS and Atom feeds into a single feed or rendered page. It fetches feeds, filters and selects entries, sorts and trims them by date, applies simple spam filtering and HTML cleaning, and then constructs an aggregate feed that you can render however you like, with hooks for customization by subclassing or roles. The module exposes a straightforward API including methods to fetch feeds, select and clean entries, cutoff by date, build the combined feed and run the whole process, and it can be used directly from code or via the provided perlanet command line and the batteries‑included Perlanet::Simple. If you need a flexible, Perl-native way to collect and publish multiple web feeds into a single stream or page, Perlanet is designed for that use.

SPVM::Resource::Coro packages the libcoro coroutine implementation for use in SPVM native extensions, making it easy to add coroutine context structures and the necessary headers, source and compiler defines to your SPVM C99 build. It bundles the coro.h and coro.c files (from Coro 6.57) and configures platform-specific compile-time flags so your native code can declare and use libcoro types such as coro_context for context switching and lightweight threads. The resource integrates with SPVM::Builder::Config so you can call use_resource and import the supplied defines into your build, and the distribution includes instructions to extract the upstream Coro files and apply a small patch before building. This is a first release distributed under the MIT License and is intended for developers who need coroutine support in SPVM native modules.

SPVM::Resource::SQLite bundles the SQLite C amalgamation and header files so you can build the SQLite engine directly into SPVM extensions without depending on a system SQLite installation. It is intended to be added to an SPVM::Builder::Config and then used from C code included in your SPVM module, for example by including sqlite3.h and calling the SQLite C API. The packaged code targets C99 and is built with flags that enable thread safety, column metadata, FTS5 full text search, R*Tree spatial indexes, JSON functions, math functions and the dbstat virtual table, so common SQLite features are available out of the box. The resource is based on the SQLite amalgamation (originally 3.45.1) and is distributed via GitHub under the MIT license, making it a convenient way to ship a self-contained, feature-rich SQLite engine with SPVM projects.

SPVM::Resource::RE2 packages the Google RE2 regular expression engine as a build-time resource for SPVM projects, making the RE2 C++17 headers and sources available to native SPVM extensions so you can call RE2 APIs from embedded C++ code. It automates pulling the upstream RE2 2023-02-01 sources into your project, provides the core headers and implementation files used by the library, and includes the necessary compiler flags, so adding fast, safe RE2 regex support to an SPVM extension is as simple as declaring the resource in your builder config. The resource mirrors the original RE2 distribution and is provided under the MIT license.

Dancer2::Plugin::Auth::Extensible is a plugin for Dancer2 web apps that provides a ready-made, extensible authentication and authorization framework. It gives you route guards like require_login and require_role, helper keywords such as logged_in_user and authenticate_user, built‑in password reset and user management features, support for multiple authentication realms, and a pluggable provider model so you can authenticate against config files, system users, databases, LDAP, IMAP, or your own provider. The module encourages secure password handling with RFC2307‑style hashed passwords and includes a small utility to generate them, and it supplies default login/logout routes while letting you override handlers or use a no-redirect “humane” login flow. It requires session support, exposes hooks for customization, and includes safeguards around email-generated links; a recent release added an uri_base setting to close a security hole that could let attackers craft malicious links in password reset and welcome emails and fixed related host handling and test issues. Use this plugin when you want a flexible, configurable authentication layer for a Dancer2 application without building everything from scratch.

SPVM::Resource::Libpng packages the libpng C library as a ready-to-use resource for SPVM so native SPVM classes can include png.h and call libpng APIs directly. It bundles the libpng v1.6.45 headers and source files and requires SPVM::Resource::Zlib for compression support, targeting the C99 standard. You enable it in your build by calling use_resource('Resource::Libpng') from SPVM::Builder::Config, which makes the needed headers and sources available when compiling SPVM native code. Recent updates raise the SPVM requirement to 0.990195, add AddressSanitizer and MSVC tests, and tweak the build config extension for improved portability and testing.

SPVM::Resource::Eigen makes the C++ Eigen linear algebra library (v3.4.0) available to SPVM projects by bundling Eigen header files and wiring them into the SPVM build environment for C++17 native code. By adding use_resource('Resource::Eigen') to your SPVM::Builder::Config you can include Eigen headers such as Eigen/Core and Eigen/Dense in your native .cpp files and use matrices, decompositions and solvers from Eigen directly inside SPVM extensions. This module is a convenience packaging of the real Eigen library for SPVM native development rather than a Perl reimplementation, so it is relevant if you plan to write performance‑sensitive numeric or linear algebra code in C++ within SPVM.

SPVM::Resource::SocketUtil provides a compact C resource for SPVM that exposes portable socket helper functions to native extensions, making it easy to read socket error numbers and obtain human readable socket error messages across platforms. You enable it in your SPVM build config and on Windows you also link the wsock32 and ws2_32 libraries, after which your C code can include the supplied header and call functions such as spvm_socket_errno and spvm_socket_strerror_nolen, with support for UNIX domain socket structures where applicable. The code targets the C99 standard for portability, is MIT licensed, and is useful whenever you need consistent, low level socket error handling in SPVM modules. Recent updates raised the SPVM requirement, improved portability and testing including ASan and MSVC, and adjusted build/config behavior.

SPVM::Resource::Utf8proc packages the utf8proc C library so SPVM native code can perform robust UTF‑8 processing without needing an external native dependency. It installs the utf8proc headers and source into your SPVM build tree, exposes the utf8proc API for inclusion from SPVM native C files, and sets the needed compile flags such as -DUTF8PROC_STATIC and the C99 standard. You use it by adding Resource::Utf8proc to your SPVM::Builder::Config and then including utf8proc.h in your SPVM native implementation to call functions like utf8proc_map. The bundled library is utf8proc v2.9.0, the package is MIT licensed, and recent updates bumped the SPVM version requirement, added ASan and MSVC tests, and adjusted build configuration handling to improve portability.

Text::ASCII::Convert is a Perl module that normalizes text by replacing non-ASCII characters with visually similar ASCII letters so you end up with a plain ASCII string. It accepts Unicode strings or UTF-8 octets and always returns bytes in the ASCII 0x00-0x7F range. The module is aimed at cases like spam detection where attackers use lookalike characters to hide words, so it maps by appearance rather than by linguistic meaning, for example turning certain accented or foreign letters into familiar Roman letters. Characters that have no ASCII lookalike are replaced by spaces and consecutive spaces are collapsed, zero width characters used for obfuscation are removed, and control characters such as tabs and newlines are preserved. If you need language-aware or semantic transliteration this is not the right tool, but if your goal is practical visual normalization for matching or filtering, this module provides a simple GPL-licensed solution.

PlackX::Framework is a lightweight framework that makes it easy to build PSGI/Plack web applications in Perl by tying together Plack::Request, Plack::Response and a small router into a minimal, easy to override structure. It automatically creates or loads per-application subclasses for handler, request, response, router and optional pieces like templating or URI helpers and exports a simple app() entry point and a compact routing DSL with route, base and filter keywords. Request and response objects include useful conveniences such as a per-request stash, a one-cycle flash cookie, rerouting and easier streaming, templating support via an optional Template component, and a hook to wrap your app in middleware. The project prioritizes low memory use, fast start-up and few dependencies while avoiding excessive magic, and it is designed to be easily extended by subclassing. The author notes the framework is still in an experimental alpha stage but used in production, and recent updates added a render_file helper, improved URI utilities and URL generation fixes along with a more consistent $response->last name for halting a request.