CPANscan

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.

Dist::Zilla::PluginBundle::GEEKRUTH is an opinionated, ready-made Dist::Zilla configuration that bundles and preconfigures the collection of plugins D. Ruth Holloway uses to build, test, version and release Perl distributions. It automates common release work such as contributor tracking, metadata (MetaYAML/MetaJSON), POD weaving and README generation, compile and release tests, automatic prerequisite detection, changelog and semantic versioning, and the git commit/tag/push steps so you do not have to assemble all those pieces yourself. You can tweak a few arguments like authority (default cpan:GEEKRUTH), builder (default MakeMaker), development and release branch names, upstream remote, autoprereqs_skip and a remove_plugin option to drop parts you do not want. This bundle is most useful if you want a proven, full-featured release pipeline modeled on Ruthie’s workflow rather than a minimal or highly bespoke setup. Recent notable changes moved the workflow to Codeberg and added a SecurityPolicy plugin.

Data::PubSub::Shared provides a lightweight, high-performance publish/subscribe system built on Linux shared memory that lets multiple processes broadcast messages into a ring buffer while each subscriber reads independently from its own cursor. Publishers never remove messages and the ring overwrites old data when full, with automatic recovery for slow subscribers and per-subscriber overflow counters to track lost messages. The module offers several types: Int, Int32, and Int16 deliver lock-free multi-producer multi-consumer publishing for compact numeric payloads and are ideal for counters, timestamps, or small events, while Str handles variable-length byte or UTF-8 strings and is better for log lines, JSON, or serialized payloads at the cost of a mutex that serializes publishers. It supports file-backed or anonymous mappings, memfd-backed sharing, futex-based blocking polls with timeouts, eventfd integration for event loops, batch operations for very high throughput, and tools for cursor management and diagnostic status. Note that it is Linux-only and requires 64-bit Perl, Str-mode publishers are serialized and recover from a dead publisher within a short timeout, and certain operations such as clearing the ring must be used carefully when publishers are active. Overall it is a practical choice when you need very fast interprocess fan-out with low overhead and simple APIs for both numeric and string messages.

DateTime::TimeZone is the core Perl module that represents time zones for the DateTime ecosystem and provides a factory for creating zone objects by name, offset, or special types like UTC or a floating zone for calendar-local times. It gives you the current offset and DST status for a DateTime object, converts human-friendly offset strings to seconds and back, and exposes catalogs of valid zone names, categories, country mappings, and links so you can present or validate time zone choices. The module hides the complex historical and DST rules by using generated Olson/IANA data and includes platform-specific helpers for discovering the system "local" zone on Windows, HPUX, Android, and others. It also provides Storable hooks to avoid bloating serialized data and advises loading needed zones in a parent process for preforked servers to save memory. This release tracks the 2026c Olson updates and includes contemporary changes affecting Alberta, Canada and Morocco.

Data::NDArray::Shared provides a compact, typed N‑dimensional numeric array that lives in a Linux shared memory mapping so multiple processes can view and mutate the same dense tensor concurrently. You can create file-backed arrays, anonymous mappings inherited across fork, or transferable memfd-backed mappings and reopen them from a file descriptor; supported element types include double and float and a range of signed and unsigned integer widths and shapes of one to eight dimensions with row‑major layout. The module gives simple indexed and flat access, bulk fills and zeroing, reshape without copying, reductions like sum/mean/min/max, in-place scalar and elementwise arithmetic, and convenient conversion to and from PDL when available, including an optional zero-copy PDL alias that bypasses the module lock and therefore requires external synchronization. Concurrent mutation is serialized with a futex write‑preferring read/write lock that recovers from dead processes so readers see consistent headers and writers do not corrupt the buffer. Limitations worth noting are Linux-only operation, 64‑bit Perl required, a 1 TiB mapping cap and integer dtypes that wrap per C casting rules and float dtypes that lose precision relative to Perl NVs. Recent 0.02 hardens security and robustness by creating backing files with mode 0600 by default and adding an option to supply an explicit file mode for intentional cross-user sharing.

Data::HashMap::Shared is a high-performance, file-backed shared-memory hash map for 64-bit Linux Perl that makes it simple to share keyed data and counters between processes without a database. It offers type-specialized variants for integer and string keys and values, a lock-free fast read path with futex-backed write locking, atomic increment/decrement and compare-and-swap operations, optional LRU eviction and per-key TTLs for use as a cross-process cache, and an arena allocator for storing larger strings in shared mmap space. You can create anonymous or memfd-backed maps, shard a workload across multiple files for parallel writers, and use either a method API or very fast XS keyword calls. The module exposes batch ops, cursors, diagnostics and explicit sync/unlink controls and is tuned for low-latency lookups and very high throughput versus LMDB and BerkeleyDB in the author’s benchmarks. Important caveats are that it is Linux-only and requires 64-bit Perl, integer variants use fixed-width two’s-complement storage so keys and values can wrap or be truncated, string keys compare by raw bytes with UTF-8 flags preserved but not part of identity, and stale-lock recovery assumes a shared PID namespace so cross-container use is unsupported; after a writer crash a map may contain a partially-updated entry so critical systems should clear after recovery. Overall it is a practical choice when you need very fast, concurrent cross-process caches, counters, queues or other shared data structures without running a separate server.

Data::Graph::Shared provides a compact, high-performance directed weighted graph that multiple Linux processes can attach to via shared memory, letting you allocate a fixed pool of nodes and edges and mutate the structure safely from different processes. It supports fast node and edge insertion, neighbor iteration, node data storage, and counters for nodes and edges, with mutex-protected updates and PID-based recovery for stale locks so concurrent programs stay robust. The graph can be file-backed or use memfd, exposes an eventfd for integration with event loops, and includes diagnostic stats and sync/unlink lifecycle controls; backing files are created with restrictive permissions by default. One design tradeoff to note is that remove_node only clears outgoing edges in O(1) and leaves incoming destinations dangling unless you use remove_node_full, which does an O(N+E) cleanup. This module is Linux-only and requires 64-bit Perl, and bench tests in its documentation show very high operation throughput for single-process workloads.

Data::Deque::Shared provides a high-performance double-ended queue that multiple Linux processes can share via anonymous mappings, memfd or file-backed shared memory, offering lock-free push and pop operations at both ends with futex-based blocking when empty or full. It comes in integer and fixed-length string variants, is designed for 64-bit Perl and capacities up to 2^31, and is targeted at multi-producer multi-consumer workloads where it outperforms older shared-string queues under contention. The API is simple: push/pop (with optional timed waits), size and capacity queries, a concurrency-safe drain operation, eventfd integration and stats that include recoveries for crashed or stalled pushers. Backing files are created with secure owner-only permissions by default and the module validates on-attach headers so attachments are safer, but if you grant write access to other users you must trust those processes not to corrupt the mapping. Recent releases hardened security and robustness, moved to a file format v2 with per-slot control data for true MPMC safety, added bounded recovery of stuck slots, and preserved UTF-8 for the string variant.

Data::Buffer::Shared provides typed, fixed-capacity buffers that live in file-backed or anonymous mmap'd shared memory so multiple processes can read and update the same data directly on Linux using 64-bit Perl. Each type variant (integers, floats, fixed-length strings) exposes atomic, lock-free single-element get/set and rich integer atomics like incr/add/CAS plus seqlock-guarded bulk reads and writes, a futex-based read/write lock with stale-lock recovery, zero-copy mmap views and raw pointers for FFI, and both keyword and method APIs for convenience. Buffers are presized and available via on-disk files, memfd objects, or anonymous mappings, making this module a good fit for high-performance IPC tasks such as counters, shared arrays, and low-latency state sharing. Backing files are created with owner-only permissions (0600) by default for improved security and you can supply an explicit file mode to share across users. Recent releases focus on security and robustness, notably the 0600 default file mode and improved dead-reader recovery, and a header version bump in 0.04 means older maps from 0.03 must be recreated.

Data::Intern::Shared provides a compact, shared-memory string interning table for Linux that maps byte strings to dense uint32 ids and back, storing each distinct string once so several processes can agree on and cheaply reference the same keys. It is useful when you want shared data structures to hold fixed-size ids instead of variable-length strings, for example to build string-keyed sorted sets by pairing it with Data::SortedSet::Shared. The module supports anonymous mappings inherited across fork, file-backed mappings, and transferable memfd descriptors so unrelated processes can attach, lookups are constant-time, and concurrent access is guarded by a futex-based write-preferring rwlock with dead-process recovery. Interning is append-only and permanent so ids stay stable for the life of the table, empty strings and embedded NULs are allowed, and limits are fixed at construction: byte-level keys only, a max number of strings and a capped arena size, and no per-string removal. Note that it is Linux-only and requires 64-bit Perl. The recent release tightened security and robustness by creating backing files with owner-only (0600) permissions by default while still permitting an explicit file mode for cross-user sharing.

RT-Extension-ExcelFeed is a plugin for Request Tracker that adds Microsoft Excel (XLSX) export capabilities so search results and scheduled dashboard reports can be saved or emailed as native Excel files. It integrates into the Query Builder feeds menu with a "Download as Microsoft Excel Spreadsheet" option and lets you send dashboard subscriptions as attached XLSX files instead of inline HTML. The extension targets RT 6.0 (with older 0.* releases for RT 5.0), installs as a standard RT plugin, and includes simple configuration switches to hide the chart download button and to control progressive row paging so large reports can be generated with lower memory use. If you need readable, portable Excel output from RT searches or scheduled reports, this extension provides a direct and easy way to produce it.

Sereal::Encoder is a fast, compact binary serializer for Perl that turns complex Perl data structures into the Sereal format (protocol version 5 by default) for efficient caching, IPC, storage or network transport. You create a persistent encoder object and call encode or use the faster sereal_encode_with_object functional wrapper to serialize data, or write straight to disk with encode_to_file. The encoder supports optional payload compression with Snappy, Zlib or Zstd, string deduplication and several safety and compatibility controls such as refusing or stripping bless information, stringifying or undefing unknown values, and freeze/ thaw callbacks so objects can control their own serialized representation. It also offers options to produce more deterministic output for cache keys and testing with canonical, canonical_refs and sort_keys, and tuning for exotic floating point support or to force standard doubles. Be aware that deep nested structures can hit recursion limits, that producing a truly canonical representation is inherently tricky in Perl because of string/number duality and other edge cases, and that encoder and decoder are released separately so you should upgrade the decoder before upgrading to encoder protocol 5. Recent notable changes include official protocol 5 support with better floating point handling and Perl 5.36 boolean support, plus ongoing build and compression library updates.

Sereal::Decoder is a high-performance Perl module for deserializing the compact binary Sereal format, letting Perl programs efficiently reconstruct complex data structures produced by Sereal::Encoder. It supports protocol versions 1 through 4 and offers both object-oriented and faster functional call styles, plus conveniences like decoding with headers, offset-based and incremental parsing, and a bytes_consumed counter to detect leftover data. The decoder includes many safety and tuning options such as refusing Snappy compression, refusing or preventing blessing of objects, disabling THAW callbacks, UTF-8 validation, and limits on recursion depth, string/array/hash sizes and uncompressed blob size to help mitigate malformed- or malicious-input attacks. It also implements the FREEZE/THAW object protocol for custom object serialization while refusing to autoload classes by default, so you can opt out if you do not trust input. Be aware that very deep nesting can exhaust the C stack and that Snappy decompression has historically been a source of unsafe behavior on invalid input, so use the provided options when handling untrusted data. This module is a good fit for Perl services that need fast, compact binary interchange, caching, or IPC where speed and space efficiency matter.

Sereal is a high-performance, compact binary serialization system for Perl that makes it easy to pack complex Perl data structures into small, fast-to-parse blobs and unpack them again. This top-level Sereal module is a thin wrapper that loads and coordinates the real workhorses Sereal::Encoder and Sereal::Decoder, provides shared encoder/decoder objects, simple functional helpers like encode_sereal and decode_sereal, file read/write helpers, and utilities to detect Sereal data, and it exposes constants for compression choices such as snappy, zlib and zstd. If you care about speed you should prefer the object oriented API or the with_object variants rather than the stateless convenience functions. Note that releases emphasize safe upgrade ordering so you should upgrade decoders before encoders, and recent releases add protocol 5 improvements including better floating point handling and broader compression and platform support.

Time::OlsonTZ::Data packages a specific release of the Olson (IANA) timezone database for Perl, making ready-to-use binary tzfiles and useful metadata available to programs. You can query the embedded database version, list canonical timezone names and their aliases, get the alias-to-canonical mappings, and fetch a country-oriented selection to help humans pick a geographical timezone, and you can ask for the pathname of the binary tzfile for any named zone. It is intended for developers who need accurate, regularly updated timezone information in their Perl apps or who want to ship the standard tzfile format with their code. The module is updated as the IANA database changes so users should plan to refresh it periodically for current rules, and long-running programs should load needed tzfiles early to avoid surprising behavior if the module is updated while running.

Crypt::Sodium::XS is a Perl XS wrapper around the libsodium cryptography library that gives you access to modern primitives for encryption, signatures, hashing, key derivation and password hashing through both object-oriented and procedural APIs. It emphasizes memory safety by returning sensitive values in protected MemVault objects and exposes libsodium features such as secretbox, box, aead, secretstream, kdf/hkdf, pwhash, generichash and low-level curve25519 operations so you can build higher-level crypto tools without reimplementing primitives. The distribution prefers using a system-installed libsodium but can build with a bundled copy and supports environment variables to control which library is used. It is new and marked experimental so it is not recommended for production use, it is not intended for multi-threaded programs and portability outside POSIX-like systems is limited. Recent updates bumped the bundled libsodium to 1.0.22 and added support for KEM, SHA-3 and XOF algorithms, and the project has received multiple security fixes and ongoing maintenance.

CPAN::Perl::Releases is a small utility module that ships a curated, static mapping of every Perl release on CPAN to the relative "authors/id/" paths where the release tarballs live, making it easy for scripts and tools to locate specific perl distribution files. Its main function, perl_tarballs, returns a hash reference that maps archive types like tar.gz, tar.bz2 or tar.xz to the CPAN author path for a given Perl version, and helper functions list the supported perl_versions and the PAUSE IDs of Perl pumpkins. The data is updated as new perl releases are published to CPAN so the module is useful for installers, mirrors, release trackers or any automation that needs precise tarball locations. Not every release has every compression format, and the changelog shows frequent updates with the latest entries adding support for recent releases such as v5.44.0-RC2.

Test::Mockingbird is a testing utility for Perl that lets you replace or wrap functions and constructors, inject fake dependencies into modules, record and inspect calls, and verify call ordering so your tests can run with controlled, isolated behavior. It provides simple functions to install mocks that return fixed values, exceptions, sequences, or custom coderefs, to spy on calls while letting the original run, to intercept new() constructors, and to inject objects into a package; mocks can be stacked, scoped to a guard object, or fully restored with restore_all. Be aware of a couple of practical limits: auto-vivified symbol table entries can make Package->can() appear true after unmocking so use defined(&Package::method) to test callability, and spy() can emit a prototype-mismatch warning when wrapping prototyped subs. In the recent 0.11 release several bug fixes were applied (including a fix for scoped restore_all and prototype-warning leakage) and new async support landed as a companion module Test::Mockingbird::Async that adds Future-based mock helpers and async spies, plus convenience features like inject_all and assert_call_order. If you write Perl test suites that need fine-grained control over dependencies, call flow, or asynchronous behavior, this module gives a compact, stackable API to create deterministic, inspectable test doubles.

App::Codit is a Perl/Tk based integrated development environment and text editor designed for Perl programmers. It offers a multi document interface with tabs and a left-side document list and uses the Tk::CodeText widget to provide syntax highlighting, code folding, smart word-aware undo/redo, auto indentation, bracket pairing, autocomplete, bookmarks and configurable tab and indent styles. The app is highly extensible through a plugin system and ships with plugins for common tasks like backups, Git integration, file browsing, snippets, a console and Pod viewing. You can customize the UI and editing behavior through a configuration window or command line options for config folders, icon themes, sessions and plugin selection. Built on the Tk::AppWindow framework, Codit exposes extension points and methods for adding tool panes and sidebars. The project has been under active development and was considered beta around version 0.10, with documentation and an issue tracker available for further support.

Tk::ListBrowser is a Perl/Tk widget that gives you a flexible, icon-capable list and browser control for graphical applications. It supports multiple layout modes including bar, column, row, list, hlist and tree so you can switch between grid, columnar and hierarchical views while keeping your data. Items can carry images, multiline text and arbitrary data, and you can add sortable headers and side columns, filter live with Ctrl+F, navigate and select with keyboard or mouse, and programmatically add, remove, hide, sort and refresh entries. Scrollbars are handled automatically and many visual and behavioral options are configurable to match your UI needs. Be aware that using custom fonts may noticeably slow refresh performance.