Enter the query into the form above. You can look for specific version of a package by using @ symbol like this: gcc@10.
API method:
GET /api/packages?search=hello&page=1&limit=20
where search is your query, page is a page number and limit is a number of items on a single page. Pagination information (such as a number of pages and etc) is returned
in response headers.
If you'd like to join our channel webring send a patch to ~whereiseveryone/toys@lists.sr.ht adding your channel as an entry in channels.scm.
This package provides an enhanced version of the compress/lzw library included in the stdlib, and supports GIF, TIFF and PDF.
This package implements reader/writer library eStargz - a lazily-pullable image format.
This package provides a Go wrapper to zstd C library.
Package archiver facilitates convenient, cross-platform, high-level archival and compression operations for a variety of formats and compression algorithms.
Features:
stream-oriented APIs
automatically identify archive and compression formats
traverse directories, archive files, and any other file uniformly as
io/fsfile systemscompress and decompress files
create and extract archive files
walk or traverse into archive files
extract only specific files from archives
insert (append) into .tar and .zip archives
read from password-protected 7-Zip files
numerous archive and compression formats supported
extensible (add more formats just by registering them)
cross-platform, static binary
pure Golang (no cgo)
multithreaded Gzip
adjust compression levels
automatically add compressed files to zip archives without re-compressing
open password-protected rar archives
Supported compression formats:
brotli (.br)
bzip2 (.bz2)
flate (.zip)
gzip (.gz)
lz4 (.lz4)
lzip (.lz)
snappy (.sz)
xz (.xz)
zlib (.zz)
zstandard (.zst)
Supported archive formats:
.zip
.tar (including any compressed variants like .tar.gz)
.rar (read-only)
.7z (read-only)
This package provides a library for reading RAR archives with Golang.
lz4 provides a streaming interface to LZ4 data streams as well as low level compress and uncompress functions for LZ4 data blocks. The implementation is based on the reference C one.
This package is a brotli compressor and decompressor implemented in Go. It was translated from the reference implementation (https://github.com/google/brotli) with the c2go tool at https://github.com/andybalholm/c2go.
This package implements a functionality for pristinely disassembling a tar archive, and stashing needed raw bytes and offsets to reassemble a validating original archive.
lz4 provides a streaming interface to LZ4 data streams as well as low level compress and uncompress functions for LZ4 data blocks. The implementation is based on the reference C one. This package provides an additional command line interface tool to compress and decompress LZ4 files.
This package implements a functionality for pristinely disassembling a tar archive, and stashing needed raw bytes and offsets to reassemble a validating original archive.
This package implements a seekable version of gzip-format compressed files, compliant with RFC 1952. This implementation allows seeking in the compressed file. In normal gzip files that can only be achieved by decompressing from the start and discarding all data until the selected offset. This gzip implementation works around this by creating a special metadata file that maps uncompressed blocks to compressed blocks allowing it to only read the compressed blocks required.
This package provides a Golang implementation of the bcrypt hash algorithm. It is a fork of github.com/jameskeane/bcrypt.
This package provides a large set of test vectors for the age file encryption format, as well as a framework to easily generate them.
The test suite can be applied to any age implementation, regardless of the language it's implemented in, and the level of abstraction of its interface. For the simplest, most universal integration, the implementation can just attempt to decrypt the test files, check the operation only succeeds if expect is success, and compare the decrypted payload. Test vectors involving unimplemented features (such as passphrase encryption or armoring) can be ignored.
Shapeshifter-IPC is a library for Go implementing the IPC protocol from the Pluggable Transports 2.0 specification.
This package was initially based on the pure go BLAKE2b implementation of Dmitry Chestnykh and merged with the (cgo dependent) AVX optimized BLAKE2 implementation (which in turn is based on the official implementation. It does so by using Go's Assembler for amd64 architectures with a golang only fallback for other architectures.
In addition to AVX there is also support for AVX2 as well as SSE. Best performance is obtained with AVX2 which gives roughly a 4X performance increase approaching hashing speeds of 1GB/sec on a single core.
Dust is an Internet protocol designed to resist a number of attacks currently in active use to censor Internet communication. While adherence to the theoretical maxims of cryptographic security is observed where possible, the focus of Dust is on real solutions to real attacks.
This package provides an implementation of the PKCS#11 API. It wraps the library closely, but uses Go idiom where it makes sense. It has been tested with SoftHSM.
Shapeshifter-Transports is a set of Pluggable Transports implementing the Go API from the Pluggable Transports 2.0 specification. Each transport implements a different method of shapeshifting network traffic. The goal is for application traffic to be sent over the network in a shapeshifted form that bypasses network filtering, allowing the application to work on networks where it would otherwise be blocked or heavily throttled.
Native Go implementation of Austin Appleby's third MurmurHash revision (aka MurmurHash3). Reference algorithm has been slightly hacked as to support the streaming mode required by Go's standard Hash interface.
This package provides a Go translation of the reference C++ code for MetroHash, a high quality, high performance hash algorithm.
This package provides primitives for generating random values.
The purpose of this package is to provide a version of arbitrary sized arithmetic, in a safer (i.e. constant-time) way, for cryptography.
This package provides a functionality to communicate directly with a Trusted Platform Module device. The libraries don't implement the entire spec for neither 1.2 nor 2.0.
Included submodules:
tpm- TPM 1.2 client librarytpm2- TPM 2.0 client library.direct- the prototype "TPMDirect" TPM 2.0 API, which is intended to (eventually) be 1:1 with the TPM 2.0 spec
This package calculates CRC64 checksums using carryless-multiplication accelerated with SIMD instructions for both ARM and x86. The code is based on the https://github.com/awesomized/crc64fast-nvme.git, crc64fast-nvme package in Rust.