CPANscan

Alien::curlimpersonate is an Alien::Base module that builds the curl-impersonate patched libcurl (with bundled BoringSSL) from source and exposes the compiler and linker flags so a Perl XS extension can link against a libcurl that mimics a real browser's TLS and HTTP/2 fingerprint (JA3/JA4 and the Akamai SETTINGS profile). It is source-only and always compiles the pinned upstream release (v1.5.6) at install time rather than locating a system package, so expect a nontrivial build that requires git, a C/C++ toolchain, cmake and ninja, Go and patch and which can take several minutes. The module provides cflags, libs and dynamic_libs but deliberately emits no rpath, so consumers should add an appropriate -Wl,-rpath based on dynamic_libs when linking. The upstream version is intentionally pinned for reproducible impersonation results, which means upgrades require a new release of this distribution.

Alien::TDLib is an installer and discovery helper for TDLib, the Telegram client library, that locates a usable libtdjson on your system or installs TDLib into the Alien share area and then reports the compiler and linker flags XS consumers need. It probes the system with pkg-config or a compile/link test and accepts system libraries only if they report version 1.8.66 or newer, otherwise it will build TDLib from source by default or fetch a vetted prebuilt shared package when ALIEN_TDLIB_PREBUILT is set. Installs are anchored to a commit or release and verified against published digests so builds are reproducible and auditable, and ALIEN_TDLIB_VERSION lets you pin a specific release or commit. A source build requires CMake 3.10+, a C++17 compiler, gperf, and OpenSSL and zlib development headers and can be memory intensive so parallelism is throttled automatically. XS module authors use Alien::TDLib->cflags and Alien::TDLib->libs to populate INC and LIBS in Makefile.PL. Note that using prebuilt packages trades convenience for third party binaries and a statically linked OpenSSL that will not pick up system updates. This distribution is a new initial release.

AmberDB is a compact, high-performance flat-file database engine for Perl that uses DB_File to provide structured record storage, automatic primary keys, on-disk indexes and an ACID-like undo-journal transaction system. It exposes a simple CRUD API plus list, field, filtered and full-text search operations with packed 8-byte binary indexing for very fast ID handling, multi-dimensional facet indexing, tiered Active/Archived query modes, and record- or table-level locking for concurrent access. The module includes language-aware normalization for search (including Turkish-specific rules), runtime schema attribute overrides, and low-level table access for bulk read/write cases, but note that bulk batch operations bypass the transaction journal so single-record methods must be used when rollback safety is required. The recent 5.02 release is the initial public CPAN/GitHub release and highlights include the packed binary indexing pipeline, index-assisted full-text search with phonetic and locale normalization, facet bitset indexing, and a multi-granularity concurrency and transaction engine, making AmberDB a good fit when you want a fast, file-backed store without running a full RDBMS.

Util::H2O::More is a compact convenience layer on top of Util::H2O that turns ordinary Perl hashrefs and JSON-like nested data into lightweight objects with generated accessors, making code that works with configuration files, HTTP/JSON responses and command-line options much cleaner and easier to read. It supplies small, practical helpers for constructors, deep objectification and de-objectification of nested HASH/ARRAY structures, INI and YAML loading and saving, HTTP::Tiny response handling with optional JSON decoding, and helpers to bind Getopt::Long option specs to object accessors, plus simple Data::Dumper-based debugging helpers and array container virtual methods like all, get, push and pop. The design preserves the underlying HASH and ARRAY refs so existing data semantics remain familiar while removing a lot of dereferencing clutter. The most notable recent change is an opt-in -lvalue mode that makes generated accessors writable as true lvalue methods so you can write code like $obj->count = 42 or $obj->name .= " Jr." while retaining the original setter-call form and backward compatibility when -lvalue is not used. If you want a lightweight, backward-compatible way to tidy up code that manipulates nested Perl data, config files, CLI options or HTTP/JSON payloads, this module is worth a look.

Perl::Tidy is the programmable interface to the perltidy formatter that parses and cleans up Perl source so it is consistent and easier to read. You call Perl::Tidy::perltidy from your code and supply files, string or array references, or objects for input, output and error streams, or let it use the usual command line arguments and a .perltidyrc file. It can return parsed configuration into hashes, accept an argv string, run prefilter and postfilter callbacks, or hand you tokenized lines through a formatter object for custom analysis or transformation. The function returns a simple exit flag to indicate success, parameter errors, or warning conditions and it sends diagnostics to configurable stderr, errorfile and logfile streams. It also includes controls for handling UTF‑8 output strings so you can choose whether Perl::Tidy encodes or leaves decoded strings alone. Recent updates in the 2026 series fixed heredoc extra spacing and added additional checks to help catch missing semicolons. The module is actively maintained and documented as Perl::Tidy version 20260826 with sources on GitHub.

Net::IDN::PP is a small, pure-Perl utility for converting internationalized domain names between their Unicode form and ASCII Punycode labels (the "xn--" names) so you can encode a Unicode hostname into an A-label or decode an A-label back to readable characters. Because it is written entirely in Perl it does not require external C libraries, which makes it easy to install on systems where libidn or ICU are not available. It implements the Punycode algorithm from RFC 3492 only, so it does not perform Nameprep or the full IDNA2008 processing required for registry or registrar provisioning. If you need strict IDNA2008 compliance use a library such as Net::LibIDN2, otherwise Net::IDN::PP is a convenient lightweight choice for simple encode/decode tasks.

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.

SPVM is a statically typed programming language that uses a Perl-like syntax and is aimed at developers who want high performance with easy interop to C, C++ and Perl. You can run quick one‑liners or full scripts with the spvm tool, compile programs ahead‑of‑time or to executables with spvmcc, and call SPVM methods directly from Perl via exchange APIs, so existing CPAN modules and Perl code can be reused. The system also supports native and precompiled classes, threads and lightweight goroutine‑style concurrency, static analysis and type inference, and a builder toolchain that helps generate and package native extensions. SPVM is still evolving and has not reached a 1.0 stability promise, so backward compatibility is not guaranteed; a recent noteworthy change is the native config file extension transition from “.config” to “.build” (the old name is being deprecated), so projects that use native classes should plan for that update. If you need a fast, statically typed language with Perl-friendly syntax and tight C/Perl integration, SPVM is worth exploring, keeping in mind its pre‑1.0 compatibility caveats.

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.