CPANscan

Net::Blossom::Server::Backend::Postgres is a Postgres-backed storage implementation for Net::Blossom::Server that keeps blob bytes and metadata inside PostgreSQL via DBI and DBD::Pg. It stores blob bodies in bytea columns so uploads and deletes can be transactional, provides a deploy_schema helper to create the necessary tables, and implements the storage contract with methods to begin uploads, commit and read blobs, fetch descriptors without bodies, delete blobs or individual owners, and list a user's descriptors with cursored pagination. You can construct it from a DSN or an existing Postgres DBI handle and supply a normalized base_url for public descriptor links. The backend serializes uploads and deletes for the same hash with PostgreSQL advisory locks while allowing concurrent operations for different hashes, but direct SQL modifications to the tables do not participate in that locking protocol. Very large public media services may still prefer to store blob bytes outside the metadata database.

Geo::Coder::List is a glue module that lets you combine many geocoding providers behind a single, simple interface so you can route queries to specific services, apply per-provider query limits, and fail over until one returns a usable result. It always keeps a fast in-memory L1 cache and can use an optional L2 cache via CHI or a plain hash, and it normalizes each provider's quirky output into a consistent structure with canonical latitude and longitude fields that work with HTML::GoogleMaps::V3 and HTML::OSM. You build a chain of geocoders with push, run geocode or reverse_geocode calls and get the first successful result (or all candidates from the winning backend in list context), set a shared LWP user agent across backends, and inspect a built-in request log which you can flush. The constructor supports cloning and environment-driven configuration via Object::Configure. Note the module currently does not accept Geo::Location::Point objects for reverse geocoding and when Geo::GeoNames returns nested candidate arrays only the first element of each subarray is used.

Map::Tube::Plugin::Graph is a small Moo role that plugs into the Map::Tube family to turn tube maps into graph objects and rendered images. It provides as_graph to yield a multiedged Graph object you can analyze or hand to GraphViz2 for custom visualisation, and as_png and as_image to produce PNG files or base64 encoded images of either the entire map or a single named line. Use it when you want to do graph‑theory work on transit networks, filter or style individual lines, or generate programmatic map images from Map::Tube data. The plugin depends on the GraphViz2 toolchain, so you will need GraphViz2 installed and recent Perl (GraphViz2 v2.61 requires perl 5.8.8 or newer) to render images.

Map::Tube::CLI is a simple command-line front end for Map::Tube maps that provides quick route queries and map generation from the terminal. It installs the map-tube script and lets you ask for shortest or preferred routes between stations, display results as a compact list or a formatted table, list available maps, lines and stations, and generate PNG images of entire maps or single lines. The tool ships with many city maps but can also use locally installed maps via a --force option. It also supports generating line mappings and line notes for deeper inspection. The module exposes a single run() entry point used by the script and is aimed at developers, sysadmins and transit enthusiasts who want a lightweight, scriptable way to query and render Map::Tube data. In the v1.0.0 release the --line_mappings output was corrected to restrict connections to the requested line and the dependency was updated to Map::Tube v5.1.0.

Map::Tube is a lightweight Perl framework for modeling transit networks and finding routes between stations, implemented as a Moo role that loads map data in JSON or XML and exposes simple methods to query stations, lines and nodes and to compute routes. Its routing prefers the fewest stops and breaks ties by minimizing line changes using a small fractional penalty, and it returns rich Route, Node and Line objects for programmatic use. The module can also list all possible routes between two points although that feature is marked experimental and can recurse deeply on very large maps. A plugin system adds useful extras such as PNG image generation of maps, output formatting to JSON/XML/YAML/string and fuzzy name lookup for stations and lines. Map::Tube includes tools and test helpers for validating map data and ships with many city maps, so it is a good fit if you need to build route-finding utilities, visualizations or simple transit APIs in Perl.

oEdtk::Main is the central module of the oEdtk toolkit designed to help batch-process structured, fixed-width text records for industrial printing and document assembly. It provides a simple procedural API to open a job, read input lines, recognize records by a key, unpack fields using declared templates, run user hooks before and after processing, and format output records for a downstream document builder, with extracted values exposed in a global data array for easy access. The module is most useful when you need to convert or reformat legacy record files into compuset or database-ready output and want an event hook model for custom transformations. The distribution also includes tooling for tracking and logging and database administration; recent 1.5xxx updates improved config file lookup order, strengthened DBAdmin CSV import and tracking fields, and added options to route warnings and errors into the tracking database. This module is presented primarily as a documented toolkit with example usage and is a good fit if you work with fixed-record file workflows in printing or document management.

Geo::Coder::Free is a Perl geocoding toolkit that lets you translate addresses to latitude/longitude using local copies of free datasets rather than paid web APIs, by building a single SQLite (or optionally Redis/MariaDB-backed) database from sources like OpenAddresses, Who'sOnFirst, MaxMind, GeoNames and OpenStreetMap. It provides a simple programmatic API and a command-line mode plus example CGI code for running a local geocoding service, and includes helper scripts to download and import large datasets into the searchable database. Setup can be resource and disk intensive and the quality of results depends on which datasets you import, so coverage is not global and MaxMind only supplies city-level data; reverse geocoding is partially implemented and a few lookups can still fail, for example some place-name formats like "London, England" are tricky. Recent work (v0.42) improves the import tool robustness, adds OSM PBF support and an LRU cache, and now tries Geo::Address::Parser before libpostal to reduce memory use during parsing.

Log::Abstraction is a simple, flexible logging layer for Perl that lets you send messages to a wide range of targets with a consistent API. You can plug in a code reference for full control, push into an array for tests, append to a file, speak to syslog or journald, or have it send email alerts, and it will fall back to Log::Log4perl as a reasonable default if you do not supply a backend. It supports standard severity levels, runtime configuration from files or environment variables, a configurable text format or a compact JSON output for log aggregation, cloning of logger instances with different thresholds, and a retrievable recent message history for inspection. Advanced behaviours include per-instance email throttling, automatic script-name discovery for syslog, and compatibility with Log::Any via an adapter. The author notes a few limitations to be aware of such as in-place mutation of the syslog configuration hash, structured key/value logging being available only to CODE-ref backends, the email throttle and some flags not being thread-safe, OpenTelemetry not yet supported, and the default-backend path effectively requiring Log::Log4perl. If you want a lightweight, backend-agnostic logger that you can adapt to custom output formats or integrate with system logging and alerting, Log::Abstraction is likely a good fit.

Crypto::Utils is a Perl toolkit that bundles reusable cryptographic helpers and protocol components to make it easier to build secure authentication and key-exchange flows. It provides implementations and utilities for modern PAKEs and related primitives such as CPace, Hash2Curve helpers, the Noise framework, OPAQUE, OPRF, SIGMA, SPAKE2Plus and SPEKE, together with base OpenSSL bindings and FFI C helper code. The module is aimed at Perl developers who want higher-level building blocks for integrating or composing cryptographic protocols instead of reimplementing low-level primitives. The distribution is actively evolving and the 0.003 release merged the bundled OpenSSL base functions into the package.

Mojolicious::Plugin::OIDC is a plugin that makes it easy to add OpenID Connect authentication and OAuth2 access token validation to a Mojolicious web app. It lets your application act as a relying party and as a resource server without becoming an identity provider. The plugin wraps OIDC-Client, creates client objects and callback routes from a simple configuration, and exposes a $c->oidc entry point you can use to trigger login redirects, validate JWT access tokens, build API user agents with token exchange, and map claims into local user fields. It supports multiple providers, claim mapping, audience aliases and expiration leeway, and includes examples for protecting routes and integrating with OpenAPI. The author recommends keeping session and token data on the server side rather than in client cookies for better security.

Catalyst::Plugin::OIDC makes it easy to add OpenID Connect authentication and OAuth 2.0 token validation to a Catalyst web application. It lets your app act as an OpenID Connect relying party and validate access tokens issued by an external authorization server while delegating protocol details to the OIDC::Client library. It does not implement an OpenID Provider. The plugin creates and caches client objects at startup, automatically adds the callback routes, and exposes a simple c->oidc($provider) entry point that returns an OIDC::Client::Plugin object you can use to check identities, redirect users to login, or build API user agents that propagate tokens. Configuration is driven from your Catalyst config where you declare providers, credentials, redirect paths, claim mappings and audience aliases. Recent releases update the dependency to newer OIDC::Client versions and align tests and behavior with upstream changes including support for PKCE. The documentation also highlights a security recommendation to keep session and token data on the server side rather than in client-side cookies.

Net::Blossom::Server::Backend::SQLite provides a SQLite-based storage backend for Net::Blossom::Server that stores blob bytes and metadata together using DBI and DBD::SQLite. It implements the server storage contract and supports schema deployment, beginning uploads, committing and retrieving blobs, fetching descriptors without bodies, deleting blobs or owner relationships, and listing a key's blobs. You can supply a file path or an existing SQLite DBI handle and configure a base_url that the module uses to build public descriptor URLs. This backend is well suited to single-node deployments, local development, and testing and can be acceptable in production when blob size, traffic, and write concurrency are controlled. Blob bodies are kept in SQLite BLOB columns to keep storage simple, so very large media archives or high-traffic public servers will usually prefer Postgres or a backend that stores bytes outside the metadata database.

Database::Abstraction is a read-only Perl ORM that gives you a single, SQL-free interface to tabular data stored as CSV/PSV/XML files, SQLite or BerkeleyDB, and it can also connect to any DBI data source via a DSN. You can perform lookups and scans with plain Perl method calls or use the fluent query builder to express comparisons, wildcards, set and logical operators and automatic joins without writing SQL. Small files may be slurped into memory for sub-millisecond lookups while DBI backends use cached prepared statements for speed, and recent 0.36 work added schema introspection, DSN portability and stricter input validation to reduce injection risks while fixing a Data::Reuse stale-address bug and Windows file-detection issues. The module is intentionally read-only and has a few practical caveats such as a historical default CSV separator of '!' (override with sep_char => ','), limited XML slurp support, slurp mode assuming a unique key column, and reduced features for BerkeleyDB backends, but if you need a lightweight, portable way to query multiple file and database formats without writing SQL this module is a good fit.

SPVM::Go brings the Go language's concurrency model into SPVM by providing goroutines, channels, select, timers, and related helpers so you can write lightweight concurrent tasks and channel-based communication inside an SPVM program. It integrates with libuv to register waits for timers, I/O and channel operations on an event loop so goroutines are suspended without busy-waiting, keeping CPU usage low and allowing many concurrent goroutines. The API lets you spawn goroutines, create buffered or unbuffered channels, use select, sleep, and perform I/O waits, but certain scheduling and I/O wait calls must be made from the main thread and will raise exceptions on invalid timeouts or I/O timeouts. If you want Go-style concurrency primitives in SPVM, SPVM::Go is a practical, efficient port with companion modules and a GitHub repository for more details.

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.