CPANscan

Preproc::Tiny is a minimal, zero-dependency preprocessor that uses plain Perl as its templating language to generate source files from ".pp" templates. You can run it from Perl or the command line and it simply strips the .pp extension to produce the output file while letting you embed Perl with line directives starting with @@ or multi-line snippets between [@ and @]. It offers handy shortcuts for appending to the output and for trimming the extra newline, exposes pp_files and pp_text for batch or in-memory processing, and works by converting the template into Perl and evaling it so any compile error shows the generated code for easy debugging. This module is useful when you want the full expressiveness of Perl inside templates without pulling in a larger templating system.

Crypt::xxHash is a Perl extension that provides very fast non-cryptographic hashing using the xxHash family. It offers 32-bit and 64-bit hash functions, xxHash3 variants including a 128-bit hex output, and convenience routines that return hex strings. A streaming API lets you incrementally update and finalize hashes for large or chunked inputs such as files. The module wraps up-to-date C code and uses native 64-bit arithmetic for performance, and published benchmarks show substantial speed improvements over older Perl bindings. It implements xxHash v0.8.0 and is distributed under the BSD license.

OIDC::Client is a Perl library for acting as an OpenID Connect and OAuth 2.0 client that helps scripts and services perform common authentication tasks such as building authorization URLs, obtaining tokens, verifying JWTs, calling userinfo and introspection endpoints, exchanging tokens for different audiences, and producing API user agents preconfigured with access tokens. It is configuration driven and handles JWT verification with automatic JWK rotation, supports modern client authentication methods including client_secret_basic, client_secret_post, client_secret_jwt, private_key_jwt, tls_client_auth and none, and includes features for PKCE and token renewal and caching. Use it directly from command line tools or batch jobs, or use one of the available framework plugins for Mojolicious, Catalyst or Dancer2 when integrating into a web application. The recent 1.08 release added PKCE support and switched random string generation to Crypt::PRNG for improved security.

Perl::Dist::APPerl provides Actually Portable Perl, a toolchain and distribution for producing a single self-contained Perl executable that runs unchanged across several x86_64 operating systems. The binary bundles Perl, its modules, and helper scripts inside a read-only ZIP filesystem so you can ship the interpreter and your application as one portable file. The apperlm manager handles project configs, building from an existing APPerl or compiling Perl from source, and supports embedding scripts that can be launched by path, by argv[0] symlink, or by a configured default script, making it easy to create single-file Perl apps as an alternative to PAR::Packer. You can add CPAN distributions and native XS extensions but adding CPAN packages currently requires providing the distribution tarballs and building from source for extensions, and building Cosmopolitan from scratch is supported only on Linux. The build process needs a zip binary and an optional assimilation step modifies the executable for certain runtime behaviors, and while gdb integration can be difficult APPerl includes helpful runtime tracing options such as --strace and function tracing with a .com.dbg file.

smallnum::XS is a fast, drop‑in XS (C-backed) implementation of the SmallNumber behavior for Perl that makes numeric operations produce compact, human-friendly rounded results at a chosen precision. You enable it with use smallnum::XS and optionally pass a precision like '0.1' or '1' to control how numbers are rounded or truncated, and then ordinary arithmetic expressions yield the shortened results shown in the examples. It is intended as a transparent, faster alternative to the pure-Perl smallnum module and exposes the same small-number helpers so you can use it where you want concise numeric output for things like display, logging, or lightweight formatting. Benchmarks included with the distribution show roughly a twofold speedup over the pure-Perl implementation, and the module is documented via perldoc, distributed on CPAN, and licensed under the Artistic License 2.0.

Sekhmet is an XS Perl module that generates ULIDs — compact, lexicographically sortable identifiers — using Horus's C primitives for Crockford base32 encoding, cryptographically secure random bytes and millisecond timestamps. It provides simple functions to produce text ULIDs and 16‑byte binary forms, create monotonic ULIDs within the same millisecond to avoid collisions, extract epoch seconds or milliseconds from a ULID, validate and compare identifiers, and convert to and from UUID v7. The implementation favors speed and cryptographic-quality randomness and works across Perl versions with optimized operations on newer Perls and an XSUB fallback on older ones. Licensed under the Artistic License 2.0, Sekhmet is a focused, lightweight choice for distributed systems, databases and logging where sortable, collision-resistant identifiers are needed.

Numeric::Matrix provides fast, SIMD-accelerated two-dimensional matrices for Perl and hooks into BLAS (Accelerate on macOS or OpenBLAS on Linux) for high-performance matrix multiplication. It offers simple constructors like zeros, ones, randn and from_array and stores data row-major so it is easy to interoperate with Perl arrays. The API covers element-wise and in-place arithmetic, scalar and unary ops, reductions, transpose and serialization, plus fused machine-learning helpers such as row-wise softmax, SiLU and GELU. The implementation uses platform SIMD paths (ARM NEON, x86 AVX2 or SSE2) with a scalar fallback and will call BLAS dgemm when available or fall back to a tiled scalar matmul, making it a practical choice for numeric work and moderate ML or linear algebra tasks in Perl. A functional nmat_* interface is also provided for imported convenience. Recent releases focus on portability and compatibility fixes to work better with older Perl builds and compilers.

Tk::AppWindow is an extendable framework on top of Perl/Tk that gives you a ready-made structure for building configurable desktop applications. It supplies an extension and plugin system, a command/callback API with before and after hooks, and centralized config variable handling so you can add features like menus, toolbars, status bars, dialogs and file pickers without wiring everything from scratch. The module also includes conveniences for logging, icon/art lookup, opening URLs, saving window geometry and running nonblocking pauses, and it supports registering commands and post‑startup or pre‑config hooks to customize behavior. If you are developing a Perl/Tk GUI and want a higher‑level, reusable architecture to manage extensions, configuration and common UI patterns, Tk::AppWindow is a practical starting point.

Data::SortedSet::Shared provides a Redis-like sorted set for Perl that lives in shared memory so multiple processes can read and update the same ordered collection of 64-bit integer members with double scores. It supplies familiar operations such as add, increment, remove, rank, range queries, pop_min/pop_max and iteration, and it supports persistence via a backing file, anonymous mappings for forked children, or transferable memfd objects. The implementation uses an order-statistics B+tree plus a hash index to give constant-time score lookups and logarithmic-time rank, insert and pop operations, and range scans are efficient and sequential. Concurrency is handled by a futex-based read/write lock that recovers if a writer dies and there is an eventfd interface to wake readers after updates. Linux-only and 64-bit Perl are required and members must be integers, with a bundled string-keyed wrapper available for text keys. This module is a good fit when you need a fast, concurrent, shared ordered set across processes with low-latency queries and durable or fork-shared storage, but be aware the lock recovery does not detect PID reuse, which the author notes as a very unlikely limitation.

Data::HyperLogLog::Shared is a Linux-only Perl module that provides a compact, shared-memory HyperLogLog sketch for estimating the number of distinct items seen by one or more processes. Instead of storing items it maintains a fixed array of small registers (about 32 KB at the default precision) and uses a fast hash to update them, so it can count huge streams of values with very little memory and about 0.8% relative error at the default precision. Multiple processes can attach to the same backing file, inherit an anonymous mapping across fork, or share a memfd, and concurrent updates are protected by a futex-based lock that recovers from dead owners. The API supports adding items singly or in bulk, merging sketches of equal precision to get union counts, clearing, and basic introspection. It requires 64-bit Perl on Linux, backing files are created mode 0600 by default for better security but you can relax that when intentionally sharing across users, and the implementation notes that PID reuse is not detected though this is very unlikely to matter in practice.

Data::Histogram::Shared is a Linux-only, 64-bit-Perl implementation of an HdrHistogram that keeps a compact, fixed-size histogram in shared memory so multiple processes can efficiently record integer values and query percentiles, min, max, mean and counts with configurable significant-figure precision. You construct it by specifying the lowest and highest trackable values and the number of significant figures, then record individual values or batches, merge histograms with identical geometry, and share the same distribution across processes via a backing file, memfd, or forked mapping. Counts live in an mmap protected by a futex-based write-preferring rwlock with dead-process recovery, so updates are fast and crash-consistent to the last completed write and memory usage depends on the value range and precision rather than the number of samples. Keep in mind the module records integers only so you must scale floating values yourself, it requires Linux and 64-bit Perl, counts saturate at 64-bit limits, and PID reuse is not detected in the rare recovery path.

Data::DisjointSet::Shared provides a compact, shared-memory union-find (disjoint-set) implementation for Linux that lets multiple processes build and query a partition of a fixed universe of integer elements. It exposes the usual union, find and connected operations and uses path compression and union-by-size for near-constant amortized performance while storing about 8*N bytes of shared state plus a small cross-process table. The structure can be backed by a file, a memfd, or created anonymously and may be inherited across fork or reopened in other processes so everyone sees the same partition. All operations that compress paths or change sets acquire a write-preferring futex lock so concurrent updates serialize and dead-process holders are recovered, but be aware that find and connected are not read-only because they perform compression. The module is Linux-only and requires 64-bit Perl. The recent update hardens security by creating backing files with mode 0600 by default and lets you pass an explicit file mode when you need cross-user sharing. If you need a small, fast, cross-process data structure for grouping or connectivity tasks, this module is a practical and robust choice.

Data::CuckooFilter::Shared provides a compact, fixed-size cuckoo filter stored in shared memory for Linux and 64-bit Perl, letting multiple processes add, test, and remove items by their bytes while keeping memory proportional to capacity rather than item size. It answers membership queries as either definitely absent or probably present with no false negatives for stored items and a very low false positive rate using 16-bit fingerprints and four-slot buckets, and it supports counting duplicates up to a saturation of eight. The table is bounded by a capacity-derived geometry and can be shared via a backing file, an anonymous mapping inherited across fork, or a memfd, and mutations are protected by a futex write-preferring rwlock with dead-process recovery so operations remain crash-consistent. Be aware that removal operates on fingerprints only so deleting an item you never added can remove a colliding fingerprint and corrupt results, there is no merge operation, and wide-character strings must be encoded to bytes first. Use this module when you need fast, cross-process approximate set membership with deletions on Linux.

Data::CountMinSketch::Shared is a Linux-only, 64-bit Perl module that implements a shared-memory Count-Min sketch for fast, memory-efficient approximate frequency counting across processes. It stores a compact d-by-w matrix of 64-bit counters sized from your epsilon and delta parameters so estimates never undercount and overcounts are bounded by epsilon times the total with high probability. You can add single items or batches, read estimates, clear the sketch, merge two sketches of identical geometry to sum their streams exactly, and share the same sketch between processes via a backing file, memfd, or an anonymous mapping inherited across fork, with a futex-based rwlock that favors writers and recovers from dead owners. Items must be provided as byte strings so you need to encode wide characters first, and backing files default to owner-only permissions but can be created with broader modes for group sharing. This module is well suited for high-throughput stream processing and heavy-hitter detection when exact counting is too costly.

Data::BloomFilter::Shared provides a compact, shared-memory Bloom filter for Linux running 64-bit Perl, letting multiple processes efficiently share a probabilistic "seen before" set without storing the items themselves. You can add items, test membership, bulk-add or merge filters built with the same geometry, and tune the tradeoff between memory and false-positive rate so a negative test is exact while a positive test is "probably present". The bit array can be shared via a backing file, inherited across fork, or exported with a memfd descriptor, and concurrent mutation is protected by a futex rwlock with dead-process recovery so many processes can add and query safely. The module exposes convenience methods for construction, introspection, estimated cardinality, syncing and unlinking the backing file, and it enforces byte-oriented inputs so you should UTF-8 encode wide-character strings first. Note it is Linux-only, requires 64-bit Perl, and file-backed mappings default to owner-only permissions unless you override them.

Math::SigFigs is a Perl module that helps you count, format, and do basic arithmetic while respecting significant-figure rules used in scientific work. It provides routines to count significant figures in a given number and to format a number to a specified number of significant figures, and it offers add, subtract, multiply, and divide operations that attempt to preserve proper sig-fig rules in the results. The formatting functions return strings so you can preserve trailing zeros when needed and the arithmetic routines handle zero as a special case so values like 0.00 can be treated with their implied precision. Be aware of a few limitations: zeros are inherently ambiguous in how many significant figures they represent, perl numeric storage can lose trailing-significance so you should pass numbers as strings when precision of trailing zeros matters, and the module cannot unambiguously format some values when scientific notation is not used. Overall this is a practical tool if you need to present or compute numbers with correct significant-figure behavior in Perl.

Test::Inter is a Perl test framework designed for interactive debugging and for writing tests in a highly readable, data‑centric form. It provides Test::More style helpers such as ok, is and isnt and add-ons like use_ok and require_ok while also letting you run a single test or a range of tests by setting TI_START, TI_END or TI_TESTNUM and by exposing the current test number as $::TI_NUM so you can easily set debugger breakpoints. Tests can be declared as simple multi line strings or as data structures which keeps the test data separate from the surrounding script and makes large suites easy to scan and edit. You can mark tests todo, skip sets of tests, set features, run file based comparisons, and choose interactive human readable output or TAP compatible output for automated runs. Configuration options can be passed to new, set with environment variables, or as globals so you can tailor behavior without changing the test code. It is not a drop in replacement for Test::More but it aims to be familiar while adding more flexible test specification and interactive control and the author reports no known bugs.

Shell::Cmd is a Perl helper for building and running sequences of shell commands with robust, high-level features so you do not have to hand-craft wrapper scripts. You add commands with cmd then run them locally or on remote hosts with run or ssh, and the module automatically handles stdout/stderr capture and merging, command echoing and dry-runs, per-command retries and alternate fallbacks, simple working-directory and environment setup, basic flow constructs, and collection of output for post‑processing. It also supports copying and running generated scripts over SSH on many hosts with optional parallelism and staggered starts. The module is aimed at straightforward command workflows rather than arbitrarily complex shell functions and it documents limits such as only modest flow support and a 200-command error-mapping ceiling. Recent updates include safer handling of environment quoting and a change to flush stored output when options are changed.

Config::Model::Systemd supplies Config::Model and the cme tool with ready-made models to view, check and edit systemd unit files, letting you inspect or sanity‑check services, sockets and timers and create or update override drop‑in files in user and system locations. You can run a graphical editor, a shell UI or one-off checks from the command line, and there is an experimental cme() API for driving edits from Perl code. The module reads units from your user config directory or /etc/systemd/system, flags unknown or duplicate parameters and preserves layering and comments so it works well for both administrators and service developers. If you need support for other unit types you can file a wishlist, and the current release updates the model to match systemd 261 while shrinking the model size and requiring Config::Model 2.163 or later.

Net::Blossom::Server is the framework-neutral server core for the Blossom content protocol, providing the routing and logic for uploads, media uploads, mirrored downloads, blob retrieval, deletion and listing while leaving HTTP or telephony gateways to adapt requests and responses. It expects a pluggable storage backend that implements the Net::Blossom::Server::Storage interface and exposes high-level operations such as receive_blob which streams data into storage while computing and validating SHA-256, handles content-length checks and optional upload size limits, and returns structured upload results; there are also HEAD preflight handlers, GET/HEAD for serving blobs, DELETE for owner-based removal, GET /list for paged listings, and PUT /mirror which coordinates with a caller-supplied mirror_fetcher to stream origin data into the server. The core is intentionally agnostic about authorization and web frameworks so gateway adapters perform signature checks and convert between native requests and Net::Blossom::Server::Request/Response objects, and configurable options include chunk size, clock, maximum upload bytes and list page size. The distribution is a new CPAN release providing this reusable server core for building Blossom-compatible services.

Net::Blossom is a lightweight Perl implementation of the Blossom protocol that provides a client and supporting utilities for working with blob storage and CDN-style servers. It includes value objects for protocol data, helpers for Blossom URIs and server lists, a BUD-11 authorization token generator, and a simple HTTP client for retrieving blobs by SHA256 or other identifiers. The module intentionally exposes a small surface and the usual entry point is Net::Blossom->client which constructs a Net::Blossom::Client for interacting with servers. Use this when you want to integrate Blossom-based storage or CDNs into Perl applications without implementing the protocol yourself. This package is the initial CPAN release.

Algorithm::Classifier::IsolationForest is a Perl implementation of Isolation Forest and Extended Isolation Forest for unsupervised anomaly detection that builds an ensemble of random trees to score and flag outliers, returning per-sample anomaly scores in (0,1] and optional binary labels. It supports classic axis-aligned splits or oblique hyperplane splits for the extended variant, a majority-voting aggregation mode, learned thresholds from a contamination parameter, several strategies for handling missing values, and named-feature support for single-row scoring. The module offers persistence to JSON, a packed-data wrapper to speed repeated scoring in interactive workflows, reproducible fits via seeding, and multiple ways to speed up training and scoring with an optional Inline::C and OpenMP backend or by forking worker processes while keeping a pure-Perl fallback that produces identical results. Overall it is a practical, feature-rich choice for detecting anomalies in numeric datasets, especially when you want flexibility over aggregation, missing-data treatment, performance tuning, and easy model saving and reloading.

CLI::Simple is a minimalist object-oriented Perl base class for building modulino-style command line tools that need options, subcommands and positional arguments. It layers Getopt::Long parsing with automatic getter/setter creation, integrates with Log::Log4perl for logging, and provides handy features like built-in help and pager support, bash completion generation, and low-dependency scaffolding tools to migrate a single-module script into a role-based project driven by a YAML manifest. In role mode it composes Role::Tiny roles declared in the manifest so you can split commands into focused modules, and it includes commands such as -dump-spec, -scaffold and -migrate to bootstrap that workflow. The module deliberately keeps the surface small and non-prescriptive so you get a simple init/run lifecycle without a heavy framework, which makes it a good fit for internal utilities and straightforward CLIs while teams needing complex interactive command trees may prefer a fuller framework like App::Cmd.

Algorithm::EventsPerSecond is a compact sliding-window meter that tracks average events per second over the last N seconds by keeping per-second counts in a fixed-size ring buffer, so memory use stays constant and updating or reading the rate is effectively constant time. You create a meter with a window size, call mark() to record events, and read rate(), count(), or total() to get the current per-second rate, the number of events in the window, or the lifetime total. An optional XS C backend with SIMD optimizations (AVX2 or SSE4.2) is built automatically when a compiler is available for higher throughput and the module falls back to a pure-Perl implementation otherwise; you can query which backend and SIMD flavor are in use via backend() and simd(). The 0.1.0 release adds a unix-socket vizier daemon, iqbi-damiq, plus example FreeBSD and systemd startup scripts to simplify centralized tracking of many meters.

Algorithm::ToNumberMunger turns simple, declarative specs into fast reusable coderefs that convert raw values into single numeric features for machine learning and analytic pipelines. You describe each field in a JSON-like spec and the module builds validated closures so you can compile your munging logic once and apply it per row with no re-parsing. It provides a large set of built-in transforms for common needs: categorical enums and protocol-aware enums, frozen frequency and n-gram tables for rarity and gibberish detection, hashing for high-cardinality labels, datetime parsing with sin/cos cyclic outputs, string-shape features like entropy and character or run counts, numeric normalisers such as log, z-score, quantile and min-max scaling, bit and IP/CIDR classification, multi-input combiners and ratios, regex matching and counting, chains of string prefilters, and even an events-per-second client that consults an external daemon. The class validates specs at build time so configuration errors are caught early and the returned closures only fail on truly un-mungeable input. It is aimed at people building feature stores, anomaly detectors or CSV writers who want a stateless, auditable, and portable way to map raw log fields into numeric features, with practical notes such as frozen frequency tables bloating shipped JSON if they get very large and the EPS munger depending on an external daemon.

WWW::Session::Storage::Redis is a lightweight Redis backend for WWW::Session that stores serialized session objects in Redis via Cache::Redis. You create it with a hashref of Cache::Redis options and a required server address, then use simple methods to save session data with a TTL, retrieve the serialized string or undef if missing, and delete sessions. A save expiration of -1 is treated as never expiring and is implemented as a ten year TTL because Redis always uses a TTL. The module requires Cache::Redis to be installed and will croak if that dependency or the server option is missing, making it a straightforward choice when you need fast, centralized session persistence backed by Redis.

DBIx::QuickDB is a small Perl helper that makes it trivial to spin up throwaway database servers for testing and development, letting you create named or ad-hoc databases for drivers like PostgreSQL, MySQL/MariaDB and SQLite and optionally DuckDB, then connect to them with DBI as if they were normal servers. You can declare databases at compile time as constants or build them at run time, control automatic start/stop and cleanup, load schema SQL on creation, clone instances and use pools for faster reuse, and point it at an existing data directory when you need to. The module exposes a flexible spec hash for options such as autostart, autostop, bootstrap, cleanup and load_sql, and it will remove temporary data dirs by default so you should never enable cleanup on any important database. Recent work has focused on making teardown reliable and safe on slow or constrained hosts and on better driver detection; notably the MariaDB driver now refuses to use several known-broken server releases that can hang under --skip-grant-tables and offers an escape hatch via QDB_MARIADB_IGNORE_BROKEN if you need to override that check.

DateTime::Lite is a lightweight, low-dependency, drop-in replacement for DateTime that preserves the familiar API while trimming startup cost and installed footprint. It provides full calendar and clock arithmetic, nanosecond-aware timestamps, leap second handling, CLDR and BCP47 locale support including automatic timezone inference from locale tags, and accurate IANA timezone handling by reading TZif binaries and evaluating POSIX footer rules. Performance-critical paths are implemented in XS and the bundled DateTime::Lite::TimeZone uses a compact SQLite store with an optional process-level memory cache so you can get both small initial overhead for short-lived scripts and high throughput for long-running services when needed. Error handling follows a non-fatal, exception-object model by default and serialization, formatting, and duration semantics mirror DateTime closely so most existing DateTime code should work with minimal changes.

HTTP::Date is a small, reliable Perl utility for converting between epoch seconds and the many date string formats you encounter in HTTP headers, log files and system tools. Its commonly used functions are time2str to produce the RFC‑1123/GMT timestamp expected by HTTP and str2time to turn a wide range of human and machine date strings back into epoch seconds, with an optional default time zone and support for named zones when Time::Zone is installed. The module also exposes parse_date which returns numeric date components or an ISO‑like string and understands formats such as RFC1123/RFC850, ISO 8601, common logfile timestamps, ctime/asctime, Unix ls and Windows dir output, while treating numeric-only dates as day/month/year rather than US month/day/year. Helper routines time2iso and time2isoz format times in local or UTC ISO style. Note that parsing dates before your system epoch may not work on all platforms and that parse_date now rejects input longer than 64 characters to avoid pathological regex backtracking attacks, a security fix addressing CVE-2026-14741.

Backblaze::B2V4 is a Perl client for Backblaze B2 Cloud Storage that wraps the service's V4 API and makes it easy to authenticate, upload and download files, manage buckets, and query file metadata from Perl scripts. You create a client with your application key and key id and then call simple methods to upload single files or large files, download by file name or by Backblaze file id, list files in a bucket, create or delete buckets, and remove file versions. The module also exposes a generic send_request method for calls not covered by the helper methods and includes a b2_client command line utility for quick get and put operations. It defaults new buckets to server side encryption and notes that bucket names must be globally unique, and the installer can test your credentials by downloading a small file if you provide test environment variables. If you already use an S3 integration you might prefer Backblaze's S3-compatible API and S3 modules, but this package is a straightforward choice for Perl projects that want native B2 V4 support.