CPANscan

Mojolicious::Plugin::Fondation::Model::DBIx::Async brings DBIx::Class::Async into Fondation-powered Mojolicious apps so you can use native DBIx::Class ResultSet APIs while database work runs in a background forked worker pool and your event loop stays responsive. It supports multiple named backends and simple model-to-table mapping in configuration, provides controller helpers to access schema and models, and returns Future objects for all async DML operations. The plugin auto-discovers Result and ResultSet classes from other plugins, forks workers lazily on first use, and performs a graceful shutdown on exit so workers are cleaned up. If you already use DBIx::Class this is a drop-in way to make queries nonblocking, just remember to retain Future chains until completion. The recent 0.03 release added Fondation setup integration, reorganized the ResultSet code and introduced a fluent ResultSet->with() helper for many-to-many prefetching along with assorted bug fixes and improved source registration.

Language::Prolog::Sugar is a small Perl helper that exports constructor subroutines so you can build Prolog terms in Perl with a Prolog-like appearance. You declare which atoms, functors, variables or chain operators you want and the module installs subs that produce Language::Prolog::Types term objects, with functor arity inferred from the number of arguments and chains making nested comma or semicolon structures easy to construct. There is also an auto_term option that AUTOLOADs undefined names as terms for rapid prototyping. It is useful when you need to generate Prolog terms to drive a Prolog engine or to create a Prolog-like DSL in Perl. The author notes it cannot reproduce Prolog operator syntax, so you still invoke constructors as functions rather than using real operator forms.

Slug is a small, fast XS-based Perl module that converts arbitrary UTF-8 text into URL-safe, SEO-friendly slugs for web apps, filenames and permalinks. It transliterates Unicode to ASCII, lowercases and replaces non-alphanumeric characters with a configurable separator and offers a simple slug() call, slug_ascii() for transliteration-only output, and slug_custom() to control separator, max length, case, transliteration and trimming. The implementation uses custom ops on Perl 5.14 and newer for minimal overhead and also exposes its C headers so the core can be reused in other projects. The initial 0.01 release includes broad Unicode transliteration coverage for Latin, Greek, Cyrillic, Vietnamese, symbols, ligatures and fullwidth characters along with custom separator support, so if you need a quick, configurable and high-performance slug generator in Perl this module is a good fit.

OpenAPI::Modern is a Perl toolkit for checking that HTTP requests and responses conform to an OpenAPI v3.0, v3.1 or v3.2 specification, returning a structured JSON::Schema::Modern::Result that shows whether a message is valid, lists detailed schema errors, and carries the deserialized parameter and body data for further processing. You build it from your OpenAPI document or schema and then call validate_request or validate_response to match incoming Mojolicious (or best-effort converted) request and response objects to the right path and operation in the spec, with support for JSON Schema dialects, format validations, default population, and bundled metaschema documents to simplify schema resolution. The module is tuned for server use where you may preload and cache parsed documents to avoid startup cost and it can handle content-encoding and media-type based parameter bodies, including examples for carrying structured data in cookies. Do note that parsing is based on Mojolicious message objects so other frameworks are converted best-effort, multipart support and some path-item $ref patterns are not implemented yet, and the module does not itself enforce Authorization schemes. If you need rigorous, spec-aware request and response validation against modern OpenAPI schemas, OpenAPI::Modern provides a comprehensive and extensible solution.

CGI::Lingua is a Perl helper for making CGI web sites multilingual by negotiating the visitor's preferred language and region against a list of languages your site supports. You construct it with the languages you provide and it exposes simple methods to get a human readable language name, the two letter language or region codes, the requested sublanguage, and a best-match translation file in a directory. It can also infer the visitor country from the client IP using common Geo modules or a Whois fallback, provide a locale object and a time zone, and tell you whether the chosen language is right-to-left so you can set HTML direction. Additional features include CLDR-like plural category selection for integers across many languages and optional CHI caching and logging integration. Note the module uses embedded plural rules rather than full Locale::CLDR, RTL detection covers primary-script RTL languages only, Whois fallbacks are slow so installing a local geo module and enabling cache is recommended, and a provided logger must be a blessed object; these are known limitations documented by the author.

Apophis is a lightweight XS Perl library that provides filesystem-backed content-addressable storage using deterministic UUID v5 identifiers derived from SHA-1. It produces the same UUID for identical content and allows different namespaces so the same bytes can map to different ID spaces, which makes it handy for deduplication, immutable artifact storage, or reproducible file identifiers. Objects are sharded into a two-level hex directory tree for scalable on-disk layout, writes are atomic, and duplicate content is naturally deduplicated so no locking is required. The API supports streaming identification of large files with constant memory, atomic store and fetch operations, existence checks, integrity verification, bulk store/find operations, and optional metadata sidecars. Apophis depends on the Horus UUID library and is a good fit when you want a simple, local CAS with deterministic IDs rather than a networked storage system.

PDF::Make is a comprehensive Perl toolkit for creating, reading, and editing PDF files. It offers a recommended high-level, chainable Builder API that handles layout, word wrap, fonts and page management for common document tasks and a low-level XS API when you need direct control of PDF objects and content streams. The distribution covers document creation, parsing and text extraction, images and TrueType fonts, annotations, interactive forms, layers and attachments, redaction and watermarks, encryption and digital signatures, and can produce linearized PDFs for fast web viewing. Runtime dependencies are minimal and the Builder API makes everyday tasks simple while the XS layer lets you implement advanced, specification-level behaviors. The recent 0.07 release fixes a Windows memory-management bug that could cause crashes on Strawberry Perl by correcting how native buffers are freed.

App::bcrypt is the packaging around a small command line utility for creating and verifying bcrypt password hashes; the Perl module distribution mainly exists to reserve the namespace and to install the utility's prerequisites rather than to provide a feature-rich library API. The tool uses Crypt::Bcrypt and is related to a couple of Mojolicious bcrypt integrations, so grab this distribution when you want a straightforward Perl-based bcrypt CLI or need to bring bcrypt support into a Perl project. The distribution is maintained on GitHub and has seen light maintenance since its 2023 initial release, including packaging and test fixes through 2026.

Eshu is a fast, XS-powered tool that normalises leading whitespace in source files for C, Perl, XS, XML/HTML, CSS, JavaScript and POD by tracking nesting and re-emitting each line with correct indentation while leaving the line contents untouched. It understands language-specific constructs such as strings, comments, heredocs, regexes, template literals and embedded POD or script blocks so it produces sensible formatting rather than naive tabbing. You can call it from Perl code, use the included eshu command line for single files or whole trees with language detection, diffs, CI check mode and options for tabs or spaces and indent width, or install the supplied vim plugin for on‑the‑fly fixes. The engine is written in C for speed and runs as a single pass scanner, making it suitable for automating style fixes in projects and CI pipelines. Recent updates fixed incorrect indentation for certain preprocessor prototypes and expanded test coverage across languages to improve reliability.

Map::Tube::Server is a lightweight Dancer2-based web application that turns Map::Tube map modules into a simple REST API for retrieving available maps, listing stations, querying stations by line, and finding the shortest route between two stations. You install the specific Map::Tube::* map modules you need and mount the server under PSGI to serve JSON endpoints that client apps can call for route and station data. The project is useful for developers who want an easy way to expose transit map data and routing logic over HTTP and it is already used in production on manwar.org, but it is still marked as a beta v1 and a few maps such as NYC and Tokyo are not yet complete. The latest release added unit tests and switched to dotted-decimal versioning while keeping dependencies in sync with the Map::Tube plugin that defines supported maps.

Data::Sync::Shared supplies a compact toolkit of cross-process synchronization primitives for Linux, implemented on file-backed shared memory and using futexes for efficient blocking. It gives you semaphores for resource limiting, barriers for process rendezvous, reader-writer locks, condition variables with a built-in mutex, and a one-time initialization gate, all with timeouts and scope-based guard objects that automatically release locks on scope exit. Segments can be file-backed, anonymous for fork-inherited use, or created as memfd descriptors that you can pass between processes, and optional eventfd integration lets these primitives play nicely with event loops. The module is crash-aware because locks record owner PIDs so peers can detect and recover from dead holders, and backing files are created securely with owner-only permissions by default. Note that this is Linux-only and requires 64-bit Perl.

Data::SpatialHash::Shared is a high-performance shared‑memory spatial index for 2D and 3D points on Linux with 64‑bit Perl, letting multiple processes map the same structure and perform fast proximity queries and bulk updates without copying data. It stores points in a sparse grid of fixed-size cells and exposes radius, k‑nearest, axis‑aligned box and single‑cell queries, batched radius queries, collision-pair iteration for interaction radii, and bulk insert/move operations that amortize locking for high throughput. The module supports unbounded Euclidean space, seamless toroidal wrap for edge‑wrapping worlds, and true spherical worlds with geo helpers and cube‑sphere chunk/LOD ids for planet-scale use cases. Mappings can be file-backed, anonymous or memfd-transferable, and the API includes introspection, tuning knobs for cell size and bucket count, eventfd integration for notifications, and safe snapshot-and-callback semantics so callbacks can mutate the map. It is designed for speed and concurrent access and includes write-preferring futex locks with automatic recovery if a writer dies, with the documented caveat that extreme PID reuse could foil lock recovery in theory.

Data::ReqRep::Shared is a Linux-only, 64-bit Perl module that implements a high-performance request/response IPC channel using a single shared-memory file so multiple clients and workers can exchange requests and targeted replies without a broker or per-connection sockets. It provides two flavors: a Str variant for variable-length byte-string requests and responses with a mutex-protected request arena, and an Int variant for single int64 values with a lock-free queue for even higher throughput. The API supports synchronous and asynchronous calls, per-request response slots, optional eventfd hooks for event-loop integration, and flexible constructors that use file-backed mappings, anonymous mappings, or memfd/FD passing for forked processes. The implementation includes crash-recovery and ABA-safe generation counters so stale locks and dead clients are reclaimed automatically, and common tuning knobs let you size the request ring, response slot pool, and response payload buffer to your workload. Recent releases focused on security and robustness, notably creating backing files with mode 0600 by default while allowing an explicit file mode for cross-user sharing.

Data::Log::Shared is a high-performance append-only write-ahead log designed for Linux and 64-bit Perl that stores variable-length entries in shared memory so multiple processes can append and many readers can replay the history from any offset. It is useful for audit trails, event sourcing, persistent debug logging and other cases where entries must be retained until explicitly discarded. Writers coordinate lock-free using atomic CAS on a tail offset while readers can iterate with read_entry or each_entry, skip abandoned partially-written slots, and block or poll for new entries via wait_for or an eventfd notification. The log can be file-backed, use a memfd, or be created from an existing file descriptor, and it exposes statistics, an eventfd, and operations to truncate or reset the log; truncation is concurrency-safe but only marks entries as logically invalid and does not reclaim physical space, while reset reclaims space by zeroing the region and must be done when no other process is active. Backing files default to owner-only permissions 0600 and on-disk headers are validated when attaching, and the module is tuned for very high throughput in single- and multi-process benchmarks.

Data::Heap::Shared provides a Linux-only, 64-bit-Perl shared-memory binary min-heap that acts as a process-shared priority queue of integer (priority, value) pairs, with lowest priority popped first. It exposes simple push, pop, pop_wait and peek operations, plus size, capacity, clear, sync and stats, and supports creation from memfd or an existing file descriptor. Operations are protected by a mutex with PID-based stale-lock recovery and use futexes and optional eventfd notification for efficient blocking and wakeups. The module is designed for high throughput and low latency, with benchmarks showing multi‑million ops/sec in single-process tests and strong multi-process aggregate performance. Note the crash-safety tradeoff: a dead process will let the module recover the mutex, but heap contents can be left partially sifted, so critical users should clear and rebuild after a recovery event. Security and robustness were recently hardened so backing files are now created with owner-only mode 0600 by default and are opened with O_NOFOLLOW and O_EXCL to reduce abuse, and recent fixes address large-capacity integer overflow and other integrity issues.

Data::BitSet::Shared provides a fixed-size bitset that lives in shared memory on Linux so multiple processes can efficiently share and update bit flags without locking. It offers atomic, CAS-based per-bit operations including set, clear, test and toggle, plus fast queries like popcount, first set or clear bit, and a string view, and it supports file-backed, anonymous (fork-inherited) or memfd-backed mappings that you can attach to by file descriptor. The implementation is optimized for speed with hardware popcount and reports millions of per-bit operations per second in benchmarks, making it well suited for shared flags, membership tracking, bloom-filter storage and resource-allocation bitmaps. Be aware that bulk word writes such as fill or zero are not safe to run concurrently with per-bit CAS operations because they write whole 64-bit words. Backing files are created with safe defaults (0600, O_NOFOLLOW, O_EXCL) and you can override the mode when creating a file to share it with other users. This module requires Linux and a 64-bit Perl build.

Number::Iterator is a small, easy-to-use Perl helper for stepping a numeric value forward and backward: you construct an iterator with a configurable interval and then advance or retreat it with overloaded ++ and -- or with iterate/deiterate methods, read or set the current value and interval, and even supply custom iterate and deiterate callbacks to implement any progression logic such as multiplying, dividing, or other transforms. It is useful for generating numeric series, encapsulating counter behavior, or keeping progression logic out of application code, and the recent 1.03 release was a minor packaging cleanup that removed pax headers.

Tlaloc lets you attach an invisible "wetness" level to any Perl scalar that automatically decays each time the variable is read, turning a normal value into a tiny stateful object without changing its string or numeric content. Wetness is an integer from 0 to 100 and evaporates by a configurable rate (default 10) on every access, with helper functions to wet (add 50), drench (set to 100), dry (remove the magic), query wetness or dryness, and get or set the evaporation rate, and an optional tied wrapper that extends the same behavior to array and hash elements when you want passive evaporation on element reads. The module is mainly a playful but practical way to attach transient metadata to variables, for example to simulate time-limited state or to experiment with per-value lifecycle behavior. Note the usual magic caveats: attaching to literals is futile because temporaries are freed, the magic lives per SV so copying a scalar does not copy its wetness, the tied wrappers control which operations trigger evaporation, and the implementation is not thread safe.

LRU::Cache provides a fast in-memory least-recently-used cache for Perl, implemented in C for maximum throughput. You create it with a fixed capacity and it automatically evicts the least recently used item when full, with all common operations such as set, get, delete, exists and peek running in constant time. There is a normal object API and a function-style API you can import for roughly 2x to 3x better performance, gets promote items to the front while peek and exists do not, and you can query size, capacity, list keys in most-recent-first order or fetch the newest and oldest entries. It is ideal for caching database results, computed values, or any hot data you want to keep in memory to cut latency. Recent changes fixed test issues on older Perls and improved compatibility with pre-5.14 Perls and Windows builds so the module works cleanly across a wider range of Perl versions.

Map::Tube::API is a lightweight Perl client for the Map::Tube REST service that makes it easy to query metro maps and routing information from Perl code; the service is currently in beta and does not require an API key. You create the client with optional base_url and version parameters or by setting MAP_BASE_URL and MAP_VERSION in the environment, and then call simple methods to get data: shortest_route to compute a route between two named stations, line_stations to list stations on a specific line, map_stations to list all stations on a map, and available_maps to discover which city maps are supported. It is intended for Perl developers who need programmatic access to subway routing and station lists rather than building their own routing backend. The recent v1.0.0 release adds a real unit test suite with a mockable user agent to validate URL construction and error handling without network access, and strengthens parameter validation to make the client more robust.

Litavis is a high-performance CSS preprocessor and compiler you use from Perl that implements its engine in C for speed and correctness. It accepts CSS with conveniences such as nested selectors, parent references, preprocessor variables, mixins, and map variables, resolves colour functions like lighten or mix at compile time, and emits either minified or pretty-printed CSS. The tool preserves input order to avoid hash randomisation issues, offers cascade-aware deduplication with configurable aggressiveness, hoists @import and @charset rules, and supports multi-file projects via parse_file and parse_dir while allowing repeated compile calls without mutating internal state and a reset method to clear accumulated data. It also passes through modern CSS features such as custom properties and calc, can write output directly to a file, and exposes its reusable C header files for downstream XS modules that want to embed the same engine. If you need a fast, predictable Perl-accessible way to author and compile enhanced CSS with compile-time colour math and safe rule merging, Litavis is likely relevant.

Map::Tube::London is a Perl library that packages a ready-made dataset of London Underground stations and lines and exposes a simple API to find routes and produce map images. You instantiate it with new and call get_shortest_route($from,$to) to receive a Map::Tube::Route object describing the shortest path between two station names, with errors thrown as Map::Tube::Exception. The distribution includes station data for Bakerloo, Central, Circle, District, DLR, Hammersmith & City, Jubilee, Metropolitan, Northern, London Overground, Piccadilly, Victoria and Waterloo & City lines. If you install Map::Tube::Plugin::Graph you can call as_image($line_name) to get a base64 encoded PNG of a specific line or the whole map when no line is specified. The module is handy for scripts, tools or small web services that need routing or static tube maps, integrates with the Map::Tube ecosystem, is maintained on GitHub and in the recent v2.0.2 release its dependency on Map::Tube was updated to v5.1.0.

OpenSearch::Client is an unofficial Perl client that lets Perl programs talk to OpenSearch clusters using a familiar Search::Elasticsearch-derived API. It provides the common tasks you expect from a search client such as connecting to a server, indexing and retrieving documents, running searches and using helpers like bulk and scroll, while remaining compatible with OpenSearch after the fork from Elasticsearch. The distribution is a maintained successor to the older Elasticsearch Perl client and includes recent practical improvements such as proxy configuration options for http and https, better support for testing against AWS Managed or proxied OpenSearch endpoints, and a few option name tweaks; full usage details are in the OpenSearch::Client::Manual.

MojoX::MojoDbWrap is a small, practical adapter that normalizes the common parts of Mojo::Pg, Mojo::SQLite and similar database objects and adds a few handy helpers so you can treat different backends the same way. It forwards basic calls like select to the underlying DB handle, exposes the wrapped object and its class, and provides convenience routines id_of and id_or_insert for finding a record id by condition or creating the row and returning its id when missing, with support for custom id column names. It also integrates optional migrations via a migrations_for mapping and is extensible through a wrappers or inserter_for mechanism so you can plug in custom creation and insert logic or pass an existing DB object. The module is aimed at Mojolicious users or any Perl app that needs a lightweight, uniform DB interface across Pg, SQLite or custom drivers, requires Perl 5.24 or later, and was formally released as an official distribution in version 0.002.

Mojolicious::Plugin::BarefootJS is a small plugin that integrates the BarefootJS server runtime into a Mojolicious application. It registers a helper named "bf" that lazily provides a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo and lets you render compiled marked templates as native Mojolicious templates. Install it with $self->plugin('BarefootJS') to expose the helper in controllers and templates, and use BarefootJS::Backend::Xslate if you need the same runtime outside Mojolicious. The module is actively maintained and is released under the MIT license.

BarefootJS::Backend::Xslate is a small adapter that lets the BarefootJS runtime render Kolon-format Text::Xslate templates. It either accepts a ready-made Text::Xslate object or builds one from a list of template paths and options, configures HTML auto-escaping, and provides the runtime hooks BarefootJS expects such as render_named which binds the runtime as the bf object, mark_raw for raw HTML, and a customizable JSON encoder. The module is framework-agnostic so it runs under PSGI/Plack or in plain scripts, and it is intended to be used with the @barefootjs/xslate compile-time adapter that emits .tx templates calling runtime helpers as bf methods. If you use BarefootJS and prefer Kolon/Text::Xslate templates this backend connects the two with minimal configuration.

BarefootJS provides a server-side runtime for templates compiled from JSX/TSX so you can render marked templates and produce client JavaScript from Perl without locking into a particular template engine or web framework. Compiled templates call the runtime for helpers, while backend plugins handle engine-specific tasks like JSON marshalling, raw-string marking, JSX children materialization and named-template rendering. The core uses only Perl core modules and you add a backend when you need one; shipping backends include Text::Xslate for PSGI/Plack and a Mojolicious integration. If you want to generate and render JSX/TSX-based templates from Perl while keeping the freedom to choose your rendering stack, BarefootJS is a lightweight, backend-driven option and it has seen active development with multiple releases through July 2026.

Text::Names::Abbreviate is a small Perl utility for producing concise, configurable abbreviations of personal names. It accepts names in "First Middle Last" or "Last, First Middle" forms and can emit styles such as "J. Q. Adams", "G.R.R.M.", "JQA", or "Adams, J. Q." using options for format, name order, and the separator appended to initials. The module NFC-normalizes Unicode input and can optionally absorb surname particles like "van" or "de" into the last name. The API is stateless and returns a plain string given a name and an options hashref. It does not detect or strip honorifics or suffixes, particle matching is case sensitive, and the compact and initials formats are lossy so re-abbreviating them will not reproduce the original. This is a handy choice when you need predictable, configurable short forms of personal names for display or text processing.

Stats::LikeR brings a broad, R-flavored toolkit of statistics and data-frame utilities to Perl, offering fast XS-backed implementations of common numeric reducers, hypothesis tests, modeling and reshaping tools and table I/O so you can do R-like analysis without leaving Perl. It understands multiple data shapes (array-of-hashes, hash-of-arrays, hash-of-hashes and array-of-arrays) and provides convenient operations such as read_table/write_table, add_data/assign, reshape helpers (aoh2hoa, hoa2aoh, aoh2hoh, hoh2hoa), summary and view, binning and quantiles, correlation and covariance, many tests (t, wilcox, kruskal, chi-sq, Fisher, KS), linear and generalized linear models with predict, PCA and more. The API returns plain Perl hashrefs and arrayrefs so results are easy to consume, it tries to follow R semantics where useful and it handles missing data and common edge cases explicitly. The module emphasizes speed and practical usability, but documents a few limitations such as Type I (sequential) ANOVA behavior and some factor-level handling in predict that require manual preprocessing when re-expanding categorical variables. If you want a comprehensive, R-like stats toolbox implemented for Perl with attention to performance and familiar data-frame idioms, this module is very relevant.

Time::Nanos gives Perl programs simple, high-resolution time functions by wrapping clock_gettime, providing nanos, micros and millis to return the current time as integer nanoseconds, microseconds or milliseconds, or if called with a true argument to return a (seconds, subunits) pair for easier elapsed-time calculations. By default it uses the system clock (realtime) but you can switch to a monotonic clock to avoid system clock adjustments using Time::Nanos::clock_source('monotonic') since clock_source is not exported. On 32-bit Perl builds nanosecond precision is coarser (roughly 256 ns) and realtime reads can occasionally appear to go backwards when the system clock is changed. Recent changes add the seconds-plus-units return option, a $CLOCK variable for external clock selection, Windows high-resolution timer support and a stopwatch example.