abstract-deque : Abstract, parameterized interface to mutable Deques ( https://github.com/rrnewton/haskell-lockfree/wiki )
abstract-deque-tests : A test-suite for any queue or double-ended queue satisfying an interface ( https://github.com/rrnewton/haskell-lockfree/wiki )
abstract-par : Type classes generalizing the functionality of the 'monad-par' library ( https://github.com/simonmar/monad-par )
ac-angle : Angles in degrees and radians ( https://hackage.haskell.org/package/AC-Angle )
ac-ppm : Trivial package for writing PPM images ( https://hackage.haskell.org/package/AC-PPM )
ac-vector : Efficient geometric vectors and transformations ( https://hackage.haskell.org/package/AC-Vector )
ac-vector-fancy : Fancy type-system stuff for AC-Vector ( https://hackage.haskell.org/package/AC-Vector-Fancy )
acid-state : Add ACID guarantees to any serializable Haskell data structure ( https://github.com/acid-state/acid-state )
action-permutations : Execute a set of actions (e.g. parsers) in each possible order ( https://hackage.haskell.org/package/action-permutations )
active : Abstractions for animation ( https://hackage.haskell.org/package/active )
adjunctions : Adjunctions and representable functors ( https://github.com/ekmett/adjunctions/ )
aes : Fast AES encryption/decryption for bytestrings ( https://hackage.haskell.org/package/AES )
aeson : Fast JSON parsing and encoding ( https://github.com/haskell/aeson )
aeson-better-errors : Better error messages when decoding JSON values ( https://github.com/hdgarrood/aeson-better-errors )
aeson-casing : Tools to change the formatting of field names in Aeson instances ( https://hackage.haskell.org/package/aeson-casing )
aeson-diff : Extract and apply patches to JSON documents ( https://github.com/ysangkok/aeson-diff )
aeson-extra : Extra goodies for aeson ( https://github.com/phadej/aeson-extra#readme )
aeson-lens : Lens of Aeson ( https://hackage.haskell.org/package/aeson-lens )
aeson-optics : Law-abiding optics for aeson ( https://github.com/phadej/aeson-optics )
aeson-pretty : JSON pretty-printing library and command-line tool ( https://github.com/informatikr/aeson-pretty )
aeson-qq : JSON quasiquoter for Haskell ( https://github.com/sol/aeson-qq#readme )
aeson-warning-parser : Library providing JSON parser that warns about unexpected fields in objects ( https://github.com/commercialhaskell/aeson-warning-parser#readme )
aeson-yaml : Output any Aeson value as YAML (pure Haskell library) ( https://github.com/clovyr/aeson-yaml )
alex : Alex is a tool for generating lexical analysers in Haskell ( https://www.haskell.org/alex/ )
alex-tools : A set of functions for a common use case of Alex ( https://hackage.haskell.org/package/alex-tools )
algebra : Constructive abstract algebra ( https://github.com/ekmett/algebra/ )
algebraic-graphs : A library for algebraic graph construction and transformation ( https://github.com/snowleopard/alga )
align : Sequence alignment algorithms ( https://hackage.haskell.org/package/align )
allocated-processor : Functional combinators for monadic actions that require (de)allocation ( https://hackage.haskell.org/package/allocated-processor )
alsa-core : Binding to the ALSA Library API (Exceptions) ( https://www.haskell.org/haskellwiki/ALSA )
alsa-mixer : Bindings to the ALSA simple mixer API ( https://github.com/ttuegel/alsa-mixer )
alsa-pcm : Binding to the ALSA Library API (PCM audio) ( https://www.haskell.org/haskellwiki/ALSA )
alsa-seq : Binding to the ALSA Library API (MIDI sequencer) ( https://www.haskell.org/haskellwiki/ALSA )
alut : A binding for the OpenAL Utility Toolkit ( https://github.com/haskell-openal/ALUT )
amazonka-cloudformation : Amazon CloudFormation SDK ( https://github.com/brendanhay/amazonka )
amazonka-cloudfront : Amazon CloudFront SDK ( https://github.com/brendanhay/amazonka )
amazonka-cloudhsm : Amazon CloudHSM SDK ( https://github.com/brendanhay/amazonka )
amazonka-cloudsearch : Amazon CloudSearch SDK ( https://github.com/brendanhay/amazonka )
amazonka-cloudsearch-domains : Amazon CloudSearch Domain SDK ( https://github.com/brendanhay/amazonka )
amazonka-cloudtrail : Amazon CloudTrail SDK ( https://github.com/brendanhay/amazonka )
amazonka-cloudwatch : Amazon CloudWatch SDK ( https://github.com/brendanhay/amazonka )
amazonka-codedeploy : Amazon CodeDeploy SDK ( https://github.com/brendanhay/amazonka )
amazonka-cognito-identity : Amazon Cognito Identity SDK ( https://github.com/brendanhay/amazonka )
amazonka-cognito-sync : Amazon Cognito Sync SDK ( https://github.com/brendanhay/amazonka )
amazonka-config : Amazon Config SDK ( https://github.com/brendanhay/amazonka )
amazonka-core : Core data types and functionality for Amazonka libraries ( https://github.com/brendanhay/amazonka )
amazonka-datapipeline : Amazon Data Pipeline SDK ( https://github.com/brendanhay/amazonka )
amazonka-devicefarm : Amazon Device Farm SDK ( https://github.com/brendanhay/amazonka )
amazonka-directconnect : Amazon Direct Connect SDK ( https://github.com/brendanhay/amazonka )
amazonka-discovery : Amazon Application Discovery Service SDK ( https://github.com/brendanhay/amazonka )
amazonka-dms : Amazon Database Migration Service SDK ( https://github.com/brendanhay/amazonka )
amazonka-dynamodb : Amazon DynamoDB SDK ( https://github.com/brendanhay/amazonka )
amazonka-ec2 : Amazon Elastic Compute Cloud SDK ( https://github.com/brendanhay/amazonka )
amazonka-ecr : Amazon EC2 Container Registry SDK ( https://github.com/brendanhay/amazonka )
amazonka-elasticache : Amazon ElastiCache SDK ( https://github.com/brendanhay/amazonka )
amazonka-elasticsearch : Amazon Elasticsearch Service SDK ( https://github.com/brendanhay/amazonka )
amazonka-elastictranscoder : Amazon Elastic Transcoder SDK ( https://github.com/brendanhay/amazonka )
amazonka-iam : Amazon Identity and Access Management SDK ( https://github.com/brendanhay/amazonka )
amazonka-kinesis : Amazon Kinesis SDK ( https://github.com/brendanhay/amazonka )
amazonka-lambda : Amazon Lambda SDK ( https://github.com/brendanhay/amazonka )
amazonka-marketplace-analytics : Amazon Marketplace Commerce Analytics SDK ( https://github.com/brendanhay/amazonka )
amazonka-opsworks : Amazon OpsWorks SDK ( https://github.com/brendanhay/amazonka )
amazonka-redshift : Amazon Redshift SDK ( https://github.com/brendanhay/amazonka )
amazonka-route53 : Amazon Route 53 SDK ( https://github.com/brendanhay/amazonka )
amazonka-route53-domains : Amazon Route 53 Domains SDK ( https://github.com/brendanhay/amazonka )
amazonka-s3 : Amazon Simple Storage Service SDK ( https://github.com/brendanhay/amazonka )
amazonka-sdb : Amazon SimpleDB SDK ( https://github.com/brendanhay/amazonka )
amazonka-ses : Amazon Simple Email Service SDK ( https://github.com/brendanhay/amazonka )
amazonka-shield : Amazon Shield SDK ( https://github.com/brendanhay/amazonka )
amazonka-sms : Amazon Server Migration Service SDK ( https://github.com/brendanhay/amazonka )
amazonka-sns : Amazon Simple Notification Service SDK ( https://github.com/brendanhay/amazonka )
amazonka-stepfunctions : Amazon Step Functions SDK ( https://github.com/brendanhay/amazonka )
amazonka-storagegateway : Amazon Storage Gateway SDK ( https://github.com/brendanhay/amazonka )
amazonka-support : Amazon Support SDK ( https://github.com/brendanhay/amazonka )
amazonka-test : Common functionality for Amazonka library test-suites ( https://github.com/brendanhay/amazonka )
amqp : Client library for AMQP servers (currently only RabbitMQ) ( https://github.com/hreinhardt/amqp )
amqp-worker : High level functions for working with message queues ( https://github.com/seanhess/amqp-worker#readme )
annotated-wl-pprint : The Wadler/Leijen Pretty Printer, with annotation support ( https://github.com/david-christiansen/annotated-wl-pprint )
ansi-terminal : Simple ANSI terminal support ( https://github.com/UnkindPartition/ansi-terminal )
ansi-terminal-types : Types and functions used to represent SGR aspects ( https://github.com/UnkindPartition/ansi-terminal )
ansi-wl-pprint : The Wadler/Leijen Pretty Printer for colored ANSI terminal output ( https://github.com/ekmett/ansi-wl-pprint )
ap-normalize : Self-normalizing applicative expressions ( https://hackage.haskell.org/package/ap-normalize )
api-field-json-th : option of aeson's deriveJSON ( https://github.com/nakaji-dayo/api-field-json-th )
appar : A simple applicative parser ( https://hackage.haskell.org/package/appar )
applicative-numbers : Applicative-based numeric instances ( http://haskell.org/haskellwiki/applicative-numbers )
apply-refact : Perform refactorings specified by the refact library ( https://github.com/mpickering/apply-refact )
argparser : Command line parsing framework for console applications ( https://hackage.haskell.org/package/argparser )
arithmoi : Efficient basic number-theoretic functions ( https://github.com/Bodigrim/arithmoi )
arrows : Arrow classes and transformers ( https://www.haskell.org/arrows/ )
ascii-progress : A simple progress bar for the console ( https://github.com/yamadapc/haskell-ascii-progress )
asn1-encoding : ASN1 data reader and writer in RAW, BER and DER forms ( https://github.com/vincenthz/hs-asn1 )
asn1-parse : Simple monadic parser for ASN1 stream types ( https://github.com/vincenthz/hs-asn1 )
asn1-types : ASN.1 types ( https://github.com/vincenthz/hs-asn1 )
assoc : swap and assoc: Symmetric and Semigroupy Bifunctors ( https://hackage.haskell.org/package/assoc )
astar : General A* search algorithm ( https://github.com/weissi/astar )
async : Run IO operations asynchronously and wait for their results ( https://github.com/simonmar/async )
async-pool : async that supports worker groups and many-to-many task dependencies ( https://hackage.haskell.org/package/async-pool )
atomic-file-ops : Functions to atomically write to files ( https://github.com/clintonmead/atomic-file-ops#readme )
atomic-primops : A safe approach to CAS and other atomic ops in Haskell ( https://github.com/rrnewton/haskell-lockfree/wiki )
atomic-write : Atomically write to a file ( https://github.com/stackbuilders/atomic-write )
attobencode : Fast Bencode encoding and parsing library ( https://bitbucket.org/FlorianHartwig/attobencode )
attojson : Simple lightweight JSON parser, generator and manipulator based on ByteString ( https://github.com/konn/AttoJSON )
attoparsec : Fast combinator parsing for bytestrings and text ( https://github.com/haskell/attoparsec )
attoparsec-aeson : Parsing of aeson's Value with attoparsec ( https://github.com/haskell/aeson )
attoparsec-binary : Binary processing extensions to Attoparsec ( https://hackage.haskell.org/package/attoparsec-binary )
attoparsec-conduit : Consume attoparsec parsers via conduit. (deprecated) ( https://github.com/snoyberg/conduit )
attoparsec-enumerator : Pass input from an enumerator to an Attoparsec parser ( https://john-millikin.com/software/attoparsec-enumerator/ )
attoparsec-iso8601 : Parsing of ISO 8601 dates, originally from aeson ( https://github.com/haskell/aeson )
attoparsec-path : Convenience bindings between path and attoparsec ( https://github.com/athanclark/attoparsec-path#readme )
authenticate : Authentication methods for Haskell web applications ( https://github.com/yesodweb/authenticate )
authenticate-kerberos : Authentication methods for Haskell web applications ( https://github.com/yesodweb/authenticate )
authenticate-oauth : Library to authenticate with OAuth for Haskell web applications ( https://github.com/yesodweb/authenticate )
auto : Denotative, locally stateful programming DSL and platform ( https://github.com/mstksg/auto )
auto-update : Efficiently run periodic, on-demand actions ( https://github.com/yesodweb/wai )
aws : Amazon Web Services (AWS) for Haskell ( https://github.com/aristidb/aws )
barbies : Classes for working with types that can change clothes ( https://github.com/jcpetruzza/barbies#readme )
base-compat : A compatibility layer for base ( https://hackage.haskell.org/package/base-compat )
base-compat-batteries : base-compat with extra batteries ( https://hackage.haskell.org/package/base-compat-batteries )
base-noprelude : \"base\" package sans \"Prelude\" module ( https://github.com/hvr/base-noprelude )
base-orphans : Backwards-compatible orphan instances for base ( https://github.com/haskell-compat/base-orphans#readme )
base-prelude : The most complete prelude formed solely from the \\ ( https://github.com/nikita-volkov/base-prelude )
base-unicode-symbols : Unicode alternatives for common functions and operators ( http://haskell.org/haskellwiki/Unicode-symbols )
base16-bytestring : RFC 4648-compliant Base16 encodings for ByteStrings ( https://github.com/haskell/base16-bytestring )
base32-bytestring : Fast base32 and base32hex codec for ByteStrings ( https://github.com/pxqr/base32-bytestring )
base58-bytestring : Implementation of BASE58 transcoding for ByteStrings ( https://bitbucket.org/s9gf4ult/base58-bytestring )
base64-bytestring : Fast base64 encoding and decoding for ByteStrings ( https://github.com/haskell/base64-bytestring )
base64-string : Base64 implementation for String's ( http://urchin.earth.li/~ian/cabal/base64-string/ )
basement : Foundation scrap box of array and string ( https://github.com/haskell-foundation/foundation#readme )
basic-prelude : An enhanced core prelude; a common foundation for alternate preludes ( https://github.com/snoyberg/basic-prelude#readme )
bcrypt : Haskell bindings to the bcrypt password hash ( https://hackage.haskell.org/package/bcrypt )
beam-automigrate : DB migration library for beam, targeting Postgres ( https://hackage.haskell.org/package/beam-automigrate )
beam-core : Type-safe, feature-complete SQL query and manipulation interface for Haskell ( https://travis.athougies.net/projects/beam.html )
beam-migrate : SQL DDL support and migrations support library for Beam ( https://travis.athougies.net/projects/beam.html )
beam-postgres : Connection layer between beam and postgres ( https://haskell-beam.github.io/beam/user-guide/backends/beam-postgres )
beam-sqlite : Beam driver for SQLite ( https://haskell-beam.github.io/beam/user-guide/backends/beam-sqlite/ )
bench-show : Show, plot and compare benchmark results ( https://github.com/composewell/bench-show )
bencode : Parser and printer for bencoded data ( https://hackage.haskell.org/package/bencode )
besout : Extended GCD of polynomials over F_p[x] ( https://hackage.haskell.org/package/besout )
bibtex : Parse, format and processing BibTeX files ( https://www.haskell.org/haskellwiki/BibTeX )
bifunctors : Bifunctors ( https://github.com/ekmett/bifunctors/ )
bimap : Bidirectional mapping between two key types ( https://github.com/joelwilliamson/bimap )
binary : Binary serialisation for Haskell values using lazy ByteStrings ( https://github.com/kolmodin/binary )
binary-communicator : Flexible way to ease transmission of binary data ( https://hackage.haskell.org/package/binary-communicator )
binary-conduit : data serialization/deserialization conduit library ( https://github.com/qnikst/binary-conduit/ )
binary-ieee754 : Backport ieee754 float double combinators to older binary ( https://github.com/winterland1989/binary-ieee754 )
binary-instances : Orphan instances for binary ( https://github.com/haskellari/binary-instances#readme )
binary-orphans : Compatibility package for binary; provides instances ( https://hackage.haskell.org/package/binary-orphans )
binary-parser : A highly-efficient but limited parser API specialised for bytestrings ( https://github.com/nikita-volkov/binary-parser )
binary-parsers : Extends binary with parsec/attoparsec style parsing combinators ( https://github.com/winterland1989/binary-parsers )
binary-search : Binary and exponential searches ( https://hackage.haskell.org/package/binary-search )
binary-serialise-cbor : Yet Another Binary Serialisation Library (compatibility shim) ( https://hackage.haskell.org/package/binary-serialise-cbor )
binary-shared : Sharing for the binary package ( http://www.leksah.org )
binary-state : Simple wrapper around Data.Binary, which adds StateT to Get/Put monads ( https://hackage.haskell.org/package/binary-state )
binary-strict : Binary deserialisation using strict ByteStrings ( https://hackage.haskell.org/package/binary-strict )
binary-tagged : Tagged binary serialisation ( https://hackage.haskell.org/package/binary-tagged )
bindings-dsl : FFI domain specific language, on top of hsc2hs ( https://github.com/jwiegley/bindings-dsl/wiki )
bindings-glfw : Low-level bindings to GLFW OpenGL library ( https://hackage.haskell.org/package/bindings-GLFW )
bindings-gpgme : Project bindings-* raw interface to gpgme ( https://github.com/jwiegley/bindings-dsl )
bindings-libzip : Low level bindings to libzip ( http://bitbucket.org/astanin/hs-libzip/ )
bindings-uname : Low-level binding to POSIX uname(3) ( https://hackage.haskell.org/package/bindings-uname )
biocore : A bioinformatics library ( https://hackage.haskell.org/package/biocore )
biofasta : Library for reading fasta sequence files ( https://patch-tag.com/r/dfornika/biofasta/home )
biopsl : Library and executables for working with PSL files ( http://biohaskell.org/ )
biosff : Library and executables for working with SFF files ( http://biohaskell.org/ )
bitarray : Mutable and immutable bit arrays ( http://code.haskell.org/~bkomuves/ )
bitmap : A library for handling and manipulating bitmaps (rectangular pixel arrays) ( https://code.haskell.org/~bkomuves/ )
bits-atomic : Atomic bit operations on memory locations for low-level synchronization ( https://hackage.haskell.org/package/bits-atomic )
bits-extras : Efficient high-level bit operations not found in Data.Bits ( https://hackage.haskell.org/package/bits-extras )
bitstring : Lazy bit strings ( http://code.haskell.org/~bkomuves/ )
bitstringrandommonad : A library which turns a bytestring into a random monad ( https://hackage.haskell.org/package/BitStringRandomMonad )
bitsyntax : A module to aid in the (de)serialisation of binary data ( https://github.com/joecrayne/hs-bitsyntax )
bitvec : Space-efficient bit vectors ( https://github.com/Bodigrim/bitvec )
bitwise : fast multi-dimensional unboxed bit packed Bool arrays ( https://code.mathr.co.uk/bitwise )
bktrees : A set data structure with approximate searching ( https://hackage.haskell.org/package/bktrees )
blake3 : BLAKE3 hashing algorithm ( https://github.com/k0001/hs-blake3 )
blank-canvas : HTML5 Canvas Graphics Library ( https://github.com/ku-fpg/blank-canvas/wiki )
blastxml : Library for reading Blast XML output ( http://biohaskell.org/ )
blaze-builder : Efficient buffered output ( https://github.com/blaze-builder/blaze-builder )
blaze-builder-conduit : Convert streams of builders to streams of bytestrings. (deprecated) ( https://github.com/snoyberg/conduit )
blaze-colonnade : Helper functions for using blaze-html with colonnade ( https://github.com/andrewthad/colonnade#readme )
blaze-html : A blazingly fast HTML combinator library for Haskell ( https://jaspervdj.be/blaze )
blaze-markup : A blazingly fast markup combinator library for Haskell ( https://jaspervdj.be/blaze )
blaze-svg : SVG combinator library ( https://github.com/diagrams/blaze-svg )
blaze-textual : Fast rendering of common datatypes ( https://github.com/bos/blaze-textual )
bloomfilter : Pure and impure Bloom Filter implementations ( https://github.com/bos/bloomfilter )
bmp : Read and write uncompressed BMP image files ( https://github.com/benl23x5/bmp )
boolean : Generalized booleans and numbers ( https://hackage.haskell.org/package/Boolean )
boomerang : Library for invertible parsing and printing ( https://hackage.haskell.org/package/boomerang )
bootstrap-types : Bootstrap CSS Framework type-safe interface ( https://hackage.haskell.org/package/bootstrap-types )
boring : Boring and Absurd types ( https://github.com/phadej/boring )
bound : Making de Bruijn Succ Less ( https://github.com/ekmett/bound/ )
boundedchan : Implementation of bounded channels ( https://hackage.haskell.org/package/BoundedChan )
bower-json : Read bower.json from Haskell ( https://github.com/hdgarrood/bower-json )
boxes : 2D text pretty-printing library ( https://hackage.haskell.org/package/boxes )
breakpoint : Set breakpoints using a GHC plugin ( https://hackage.haskell.org/package/breakpoint )
brick : A declarative terminal user interface library ( https://github.com/jtdaugherty/brick/ )
brick-list-skip : Skip a certain kind of items when moving in brick list ( https://codeberg.org/amano.kenji/brick-list-skip )
brick-tabular-list : Tabular list widgets for brick ( https://codeberg.org/amano.kenji/brick-tabular-list )
broadcast-chan : Closable, fair, single-wakeup channel type that avoids 0 reader space leaks ( https://github.com/merijn/broadcast-chan )
bsb-http-chunked : Chunked HTTP transfer encoding for bytestring builders ( https://github.com/sjakobi/bsb-https-chunked )
bson : BSON documents are JSON-like objects with a standard binary encoding ( https://github.com/mongodb-haskell/bson )
btrfs : Bindings to the btrfs API ( https://github.com/redneb/hs-btrfs )
bug : Better alternatives to the \"error\" function ( https://github.com/nikita-volkov/bug )
buster : Almost but not quite entirely unlike FRP ( http://vis.renci.org/jeff/buster )
butcher : Chops a command or program invocation into digestable pieces ( https://github.com/lspitzner/butcher/ )
byline : Library for creating command-line interfaces (colors, menus, etc.) ( https://github.com/pjones/byline )
byte-order : Portable big-endian and little-endian conversions ( https://github.com/andrewthad/byte-order )
byteable : Type class for sequence of bytes ( https://github.com/vincenthz/hs-byteable )
bytebuild : Serialize to a small byte arrays ( https://github.com/byteverse/bytebuild )
bytedump : Flexible byte dump helpers for human readers ( https://github.com/vincenthz/hs-bytedump )
byteorder : Exposes the native endianness or byte ordering of the system ( http://community.haskell.org/~aslatter/code/byteorder )
bytes : Sharing code for serialization between binary and cereal ( https://github.com/ekmett/bytes )
byteslice : Slicing managed and unmanaged memory ( https://github.com/andrewthad/byteslice )
bytesmith : Nonresumable byte parser ( https://github.com/andrewthad/bytesmith )
bytestring-builder : The new bytestring builder, packaged outside of GHC ( https://hackage.haskell.org/package/bytestring-builder )
bytestring-conversion : Type-classes to convert values to and from ByteString ( https://github.com/twittner/bytestring-conversion/ )
bytestring-encoding : ByteString - Text converter based on GHC.IO.Encoding ( https://github.com/msakai/bytestring-encoding#readme )
bytestring-lexing : Parse and produce literals efficiently from strict or lazy bytestrings ( https://code.haskell.org/~wren/ )
bytestring-mmap : mmap support for strict ByteStrings ( http://code.haskell.org/~dons/code/bytestring-mmap/ )
bytestring-nums : Parse numeric literals from ByteStrings ( https://github.com/solidsnack/bytestring-nums )
bytestring-progress : A library for tracking the consumption of a lazy ByteString ( https://github.com/acw/bytestring-progress )
bytestring-show : Efficient conversion of values into readable byte strings ( http://code.haskell.org/~dolio/ )
bytestring-strict-builder : An efficient strict bytestring builder ( https://github.com/nikita-volkov/bytestring-strict-builder )
bytestring-to-vector : Convert between ByteString and Vector.Storable without copying ( https://github.com/sheyll/bytestring-to-vector )
bytestring-trie : An efficient finite map from (byte)strings to values ( http://wrengr.org )
bzlib : Compression and decompression in the bzip2 format ( https://hackage.haskell.org/package/bzlib )
c2hs : C-Haskell FFI tool that gives some cross-language type safety ( https://github.com/haskell/c2hs )
cabal : A framework for packaging Haskell software ( https://www.haskell.org/cabal/ )
cabal-described : Described functionality for types in Cabal ( https://github.com/haskell/cabal#readme )
cabal-doctest : A Setup.hs helper for running doctests ( https://github.com/haskellari/cabal-doctest )
cabal-file-th : Template Haskell expressions for reading fields from a project's cabal file ( https://github.com/nkpart/cabal-file-th )
cabal-fmt : Format .cabal files ( https://hackage.haskell.org/package/cabal-fmt )
cabal-install : The command-line interface for Cabal and Hackage ( https://www.haskell.org/cabal/ )
cabal-install-parsers : Utilities to work with cabal-install files ( https://haskell-ci.rtfd.org/ )
cabal-install-solver : The command-line interface for Cabal and Hackage ( https://www.haskell.org/cabal/ )
cabal-macosx : Cabal support for creating Mac OSX application bundles ( https://github.com/danfran/cabal-macosx )
cabal-plan : Library and utility for processing cabal's plan.json file ( https://hackage.haskell.org/package/cabal-plan )
cabal-quickcheck : QuickCheck instances for types in Cabal ( https://github.com/haskell/cabal#readme )
cabal-rpm : RPM packaging tool for Haskell Cabal-based packages ( https://github.com/juhp/cabal-rpm )
cabal-syntax : A library for working with .cabal files ( https://www.haskell.org/cabal/ )
cabal-tree-diff : tree-diff for Cabal ( https://github.com/haskell/cabal#readme )
cairo : Binding to the Cairo library ( https://projects.haskell.org/gtk2hs/ )
calamity : A library for writing discord bots in haskell ( https://github.com/simmsb/calamity )
calamity-commands : A library for declaring, parsing, and invoking text-input based commands ( https://github.com/simmsb/calamity )
call-stack : Use GHC call-stacks in a backward compatible way ( https://github.com/sol/call-stack#readme )
canonical-filepath : Abstract data type for canonical file paths ( https://github.com/nominolo/canonical-filepath )
carray : A C-compatible array library ( https://hackage.haskell.org/package/carray )
casa-client : Client for Casa ( https://hackage.haskell.org/package/casa-client )
casa-types : Types for Casa ( https://hackage.haskell.org/package/casa-types )
cascading : DSL for HTML CSS (Cascading Style Sheets) ( https://hackage.haskell.org/package/cascading )
case-insensitive : Case insensitive string comparison ( https://github.com/basvandijk/case-insensitive )
cassava : A CSV parsing and encoding library ( https://github.com/haskell-hvr/cassava )
cassava-megaparsec : Megaparsec parser of CSV files that plays nicely with Cassava ( https://github.com/stackbuilders/cassava-megaparsec )
categories : The Categories package authored by Edward Kmett ( https://github.com/ekmett/categories )
cautious-file : Ways to write a file cautiously, reducing chances of data loss due to crashes ( https://hackage.haskell.org/package/cautious-file )
cborg : Concise Binary Object Representation (CBOR) ( https://hackage.haskell.org/package/cborg )
cborg-json : A library for encoding JSON as CBOR ( https://github.com/well-typed/cborg )
cc-delcont : Delimited continuations and dynamically scoped variables ( http://code.haskell.org/~dolio/CC-delcont )
cereal : A binary serialization library ( https://github.com/GaloisInc/cereal )
cereal-conduit : Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits ( https://github.com/snoyberg/conduit )
cereal-text : Data.Text instances for the cereal serialization library ( https://github.com/ulikoehler/cereal-text )
cereal-vector : Serialize instances for Data.Vector types ( https://github.com/acfoltzer/cereal-vector )
cgi : A library for writing CGI programs ( https://github.com/cheecheeo/haskell-cgi )
charset : Fast unicode character sets based on complemented PATRICIA tries ( https://github.com/ekmett/charset )
charsetdetect-ae : Character set detection using Mozilla's Universal Character Set Detector ( https://github.com/aelve/charsetdetect-ae )
chart : A library for generating 2D Charts and Plots ( https://github.com/timbod7/haskell-chart/wiki )
chart-cairo : Cairo backend for Charts ( https://github.com/timbod7/haskell-chart/wiki )
chart-diagrams : Diagrams backend for Charts ( https://github.com/timbod7/haskell-chart/wiki )
chart-gtk : Utility functions for using the chart library with GTK ( https://github.com/timbod7/haskell-chart/wiki )
chaselev-deque : Chase and Lev work-stealing lock-free double-ended queues (deques) ( https://github.com/rrnewton/haskell-lockfree/wiki )
chasingbottoms : For testing partial and infinite values ( https://hackage.haskell.org/package/ChasingBottoms )
cheapskate : Experimental markdown processor ( https://github.com/jgm/cheapskate )
checkers : Check properties on standard classes and data structures ( https://github.com/haskell-checkers/checkers )
chell : A simple and intuitive library for automated testing ( https://github.com/typeclasses/chell )
chell-quickcheck : QuickCheck support for the Chell testing library ( https://github.com/typeclasses/chell )
chimera : Lazy infinite streams with O(1) indexing and applications for memoization ( https://github.com/Bodigrim/chimera#readme )
chr-data : Datatypes required for chr library ( https://github.com/atzedijkstra/chr )
chr-parse : Parsing for chr library ( https://github.com/atzedijkstra/chr )
chr-pretty : Pretty printing for chr library ( https://github.com/atzedijkstra/chr )
chronos : A high-performance time library ( https://github.com/andrewthad/chronos )
chunked-data : Typeclasses for dealing with various chunked data representations ( https://github.com/snoyberg/mono-traversable#readme )
cipher-aes : Fast AES cipher implementation with advanced mode of operations ( https://github.com/vincenthz/hs-cipher-aes )
cipher-aes128 : AES and common modes using AES-NI when available ( https://github.com/TomMD/cipher-aes128 )
cipher-camellia : Camellia block cipher primitives ( https://github.com/vincenthz/hs-crypto-cipher )
cipher-des : DES and 3DES primitives ( https://github.com/vincenthz/hs-crypto-cipher )
cipher-rc4 : Fast RC4 cipher implementation ( https://github.com/vincenthz/hs-cipher-rc4 )
circle-packing : Simple heuristic for packing discs of varying radii in a circle ( https://hackage.haskell.org/package/circle-packing )
citeproc : Generates citations and bibliography from CSL styles ( https://hackage.haskell.org/package/citeproc )
clash-cores : A collection of IP cores for Clash ( https://github.com/clash-lang/clash-compiler )
clash-ffi : Interact with Simulators from Clash ( https://github.com/clash-lang/clash-compiler )
clash-ghc : Clash: a functional hardware description language - GHC frontend ( https://clash-lang.org/ )
clash-lib : Clash: a functional hardware description language - As a library ( https://clash-lang.org/ )
clash-prelude : Clash: a functional hardware description language - Prelude library ( https://clash-lang.org/ )
clash-prelude-hedgehog : Hedgehog Generators for clash-prelude ( https://github.com/clash-lang/clash-compiler )
classify : Library for classification of media files ( https://hackage.haskell.org/package/classify )
classy-prelude : A typeclass-based Prelude ( https://github.com/snoyberg/mono-traversable#readme )
classy-prelude-conduit : conduit instances for classy-prelude ( https://github.com/snoyberg/mono-traversable#readme )
classy-prelude-yesod : Provide a classy prelude including common Yesod functionality ( https://github.com/snoyberg/mono-traversable#readme )
clevercss : A CSS preprocessor ( http://sandbox.pocoo.org/clevercss-hs/ )
cli : Command Line Interface ( https://github.com/vincenthz/hs-cli#readme )
clientsession : Securely store session data in a client-side cookie ( https://github.com/yesodweb/clientsession/tree/master )
clock : High-resolution clock functions: monotonic, realtime, cputime ( https://github.com/corsis/clock )
cmark : Fast, accurate CommonMark (Markdown) parser and renderer ( https://github.com/jgm/cmark-hs )
cmark-gfm : Fast, accurate GitHub Flavored Markdown parser and renderer ( https://github.com/kivikakk/cmark-gfm-hs )
cmdargs : Command line argument processing ( https://github.com/ndmitchell/cmdargs#readme )
co-log-core : Composable Contravariant Comonadic Logging Library ( https://github.com/co-log/co-log-core )
code-page : Windows code page library for Haskell ( https://github.com/RyanGlScott/code-page )
codec-compression-lzf : LZF compression bindings ( https://www.cs.helsinki.fi/u/ekarttun/Codec-Compression-LZF/ )
codec-image-devil : An FFI interface to the DevIL library ( https://hackage.haskell.org/package/Codec-Image-DevIL )
colock : thread-friendly file locks that don't block the entire program ( https://hackage.haskell.org/package/colock )
colonnade : Generic types and functions for columnar encoding and decoding ( https://github.com/andrewthad/colonnade#readme )
color : Color spaces and conversions between them ( https://github.com/lehins/Color )
colorize-haskell : Highlight Haskell source ( https://github.com/yav/colorize-haskell )
colour : A model for human colour/color perception ( https://www.haskell.org/haskellwiki/Colour )
colourista : Convenient interface for printing colourful messages ( https://github.com/kowainik/colourista )
command-qq : Quasiquoters for external commands ( http://biegunka.github.io/command-qq/ )
commonmark : Pure Haskell commonmark parser ( https://github.com/jgm/commonmark-hs )
commonmark-extensions : Pure Haskell commonmark parser ( https://github.com/jgm/commonmark-hs )
commonmark-pandoc : Bridge between commonmark and pandoc AST ( https://github.com/jgm/commonmark-hs )
commutative-semigroups : Commutative semigroups ( https://hackage.haskell.org/package/commutative-semigroups )
comonad-extras : Exotic comonad transformers ( https://github.com/ekmett/comonad-extras/ )
comonad-transformers : This package has been merged into comonad 4.0 ( https://github.com/ekmett/comonad-transformers/ )
comonads-fd : This package has been merged into comonad 4.0 ( https://github.com/ekmett/comonads-fd/ )
compact : Non-GC'd, contiguous storage for immutable data structures ( https://github.com/ezyang/compact )
companion : A Haskell library to provide companion threads ( https://github.com/commercialhaskell/companion#readme )
composition : Combinators for unorthodox function composition ( https://hackage.haskell.org/package/composition )
concatenative : A library for postfix control flow ( https://patch-tag.com/r/salazar/concatenative/snapshot/current/content/pretty )
conceit : Concurrent actions that may fail with a value ( https://hackage.haskell.org/package/conceit )
concise : Utilities for Control.Lens.Cons ( https://github.com/frasertweedale/hs-concise )
concurrency : Typeclasses, functions, and data types for concurrency and STM ( https://github.com/barrucadu/dejafu )
concurrent-extra : Extra concurrency primitives ( https://github.com/basvandijk/concurrent-extra )
concurrent-output : Ungarble output from several threads or commands ( https://hackage.haskell.org/package/concurrent-output )
concurrent-split : MVars and Channels with distinguished input and output side ( https://hackage.haskell.org/package/concurrent-split )
concurrent-supply : A fast concurrent unique identifier supply with a pure API ( https://github.com/ekmett/concurrent-supply/ )
concurrentoutput : Ungarble output from several threads ( https://hackage.haskell.org/package/concurrentoutput )
cond : Basic conditional and boolean operators with monadic variants ( https://github.com/kallisti-dev/cond )
conduit : Streaming data processing library ( https://github.com/snoyberg/conduit )
conduit-audio : Combinators to efficiently slice and dice audio streams ( https://github.com/mtolly/conduit-audio )
conduit-audio-lame : conduit-audio interface to the LAME MP3 library ( https://github.com/mtolly/conduit-audio )
conduit-audio-samplerate : conduit-audio interface to the libsamplerate resampling library ( https://github.com/mtolly/conduit-audio )
conduit-audio-sndfile : conduit-audio interface to the libsndfile audio file library ( https://github.com/mtolly/conduit-audio )
conduit-combinators : Commonly used conduit functions, for both chunked and unchunked data ( https://github.com/snoyberg/mono-traversable#readme )
conduit-extra : Batteries included conduit: adapters for common libraries ( https://github.com/snoyberg/conduit )
conduit-parse : Parsing framework based on conduit ( https://github.com/k0ral/conduit-parse )
config-ini : A library for simple INI-based configuration files ( https://github.com/aisamanra/config-ini )
config-schema : Schema definitions for the config-value package ( https://github.com/glguy/config-schema )
config-value : Simple, layout-based value language similar to YAML or JSON ( https://github.com/glguy/config-value )
configfile : Configuration file reading and writing ( http://software.complete.org/configfile )
configurator : Configuration management ( https://github.com/bos/configurator )
constraints : Constraint manipulation ( https://github.com/ekmett/constraints/ )
constraints-deriving : Manipulating constraints and deriving class instances programmatically ( https://github.com/achirkin/constraints-deriving#readme )
constraints-extras : Utility package for constraints ( https://github.com/obsidiansystems/constraints-extras )
containers-unicode-symbols : Unicode alternatives for common functions and operators ( https://haskell.org/haskellwiki/Unicode-symbols )
contiguous : Unified interface for primitive arrays ( https://github.com/andrewthad/contiguous )
continued-fractions : Continued fractions ( https://github.com/rockbmb/continued-fractions )
contravariant : Contravariant functors ( https://github.com/ekmett/contravariant/ )
contravariant-extras : Extras for the \"contravariant\" package ( https://github.com/nikita-volkov/contravariant-extras )
control-monad-exception : Explicitly typed, checked exceptions with stack traces ( http://pepeiborra.github.com/control-monad-exception )
control-monad-free : Free monads and monad transformers ( https://github.com/pepeiborra/control-monad-free )
control-monad-loop : Simple monad transformer for imperative-style loops ( https://github.com/joeyadams/haskell-control-monad-loop )
control-timeout : Timeout handling ( https://hackage.haskell.org/package/control-timeout )
converge : Limit operations for converging sequences ( https://hackage.haskell.org/package/converge )
conversion : Universal converter between values of different types ( https://github.com/nikita-volkov/conversion )
conversion-bytestring : \"Conversion\" instances for the \"bytestring\" library ( https://github.com/nikita-volkov/conversion-bytestring )
conversion-text : \"Conversion\" instances for the \"text\" library ( https://github.com/nikita-volkov/conversion-text )
convertible : Typeclasses and instances for converting between types ( https://hackage.haskell.org/package/convertible )
cookie : HTTP cookie parsing and rendering ( https://github.com/snoyberg/cookie )
cordering : An algebraic data type similar to Prelude Ordering ( https://hackage.haskell.org/package/COrdering )
coroutine-object : Object-oriented programming realization using coroutine ( https://hackage.haskell.org/package/coroutine-object )
couchdb : CouchDB interface ( https://github.com/hsenag/haskell-couchdb/ )
country-codes : ISO 3166 country codes and i18n names ( https://github.com/prowdsponsor/country-codes )
cpphs : A liberalised re-implementation of cpp, the C pre-processor ( https://projects.haskell.org/cpphs/ )
cprng-aes : Crypto Pseudo Random Number Generator using AES in counter mode ( https://github.com/vincenthz/hs-cprng-aes )
cpu : Cpu information and properties helpers ( https://github.com/vincenthz/hs-cpu )
crack : A haskell binding to cracklib ( https://hackage.haskell.org/package/crack )
cracknum : Crack various integer, floating-point data formats ( https://github.com/LeventErkok/CrackNum )
crc16 : Calculate the crc16-ccitt ( https://hackage.haskell.org/package/crc16 )
criterion : Robust, reliable performance measurement and analysis ( https://www.serpentine.com/criterion )
criterion-measurement : Criterion measurement functionality and associated types ( https://github.com/haskell/criterion )
cron : Cron datatypes and Attoparsec parser ( https://github.com/michaelxavier/cron )
crypto : Collects together existing Haskell cryptographic functions into a package ( https://hackage.haskell.org/package/Crypto )
crypto-api : A generic interface for cryptographic operations ( https://github.com/TomMD/crypto-api )
crypto-api-tests : A test framework and KATs for cryptographic operations ( http://trac.haskell.org/crypto-api/wiki )
crypto-cipher-tests : Generic cryptography cipher tests ( https://github.com/vincenthz/hs-crypto-cipher )
crypto-cipher-types : Generic cryptography cipher types ( https://github.com/vincenthz/hs-crypto-cipher )
crypto-numbers : Cryptographic numbers: functions and algorithms ( https://github.com/vincenthz/hs-crypto-numbers )
crypto-pubkey : Public Key cryptography ( https://github.com/vincenthz/hs-crypto-pubkey )
crypto-pubkey-types : Generic cryptography Public keys algorithm types ( https://github.com/vincenthz/hs-crypto-pubkey-types )
crypto-random : Simple cryptographic random related types ( https://github.com/vincenthz/hs-crypto-random )
crypto-random-api : Simple random generators API for cryptography related code ( https://github.com/vincenthz/hs-crypto-random-api )
cryptohash : collection of crypto hashes, fast, pure and practical ( https://github.com/vincenthz/hs-cryptohash )
cryptohash-conduit : cryptohash conduit ( https://github.com/vincenthz/hs-cryptohash-conduit )
cryptohash-cryptoapi : Crypto-api interfaces for cryptohash ( https://github.com/vincenthz/hs-cryptohash-cryptoapi )
cryptohash-md5 : Fast, pure and practical MD5 implementation ( https://github.com/haskell-hvr/cryptohash-md5 )
cryptohash-sha1 : Fast, pure and practical SHA-1 implementation ( https://github.com/haskell-hvr/cryptohash-sha1 )
cryptohash-sha256 : Fast, pure and practical SHA-256 implementation ( https://github.com/hvr/cryptohash-sha256 )
cryptohash-sha512 : Fast, pure and practical SHA-512 implementation ( https://github.com/hvr/cryptohash-sha512 )
crypton : Cryptography Primitives sink ( https://github.com/kazu-yamamoto/crypton )
crypton-conduit : crypton conduit ( https://github.com/psibi/crypton-conduit )
crypton-connection : Simple and easy network connections API ( https://github.com/kazu-yamamoto/crypton-connection )
crypton-x509 : X509 reader and writer ( https://github.com/kazu-yamamoto/crypton-certificate )
crypton-x509-store : X.509 collection accessing and storing methods ( https://github.com/kazu-yamamoto/crypton-certificate )
crypton-x509-system : Handle per-operating-system X.509 accessors and storage ( https://github.com/kazu-yamamoto/crypton-certificate )
crypton-x509-validation : X.509 Certificate and CRL validation ( https://github.com/kazu-yamamoto/crypton-certificate )
cryptonite : Cryptography Primitives sink ( https://github.com/haskell-crypto/cryptonite )
cryptonite-conduit : cryptonite conduit ( https://github.com/haskell-crypto/cryptonite-conduit )
cryptostore : Serialization of cryptographic data types ( https://github.com/ocheron/cryptostore )
css-text : CSS parser and renderer ( https://github.com/yesodweb/css-text.git#readme )
csv : CSV loader and dumper ( https://hackage.haskell.org/package/csv )
cubicbezier : Efficient manipulating of 2D cubic bezier curves ( https://hackage.haskell.org/package/cubicbezier )
cuda : FFI binding to the CUDA interface for programming NVIDIA GPUs ( https://github.com/tmcdonell/cuda )
cufft : Haskell bindings for the CUFFT library ( https://github.com/robeverest/cufft )
curl : Haskell binding to libcurl ( https://hackage.haskell.org/package/curl )
curly-expander : Curly braces (brackets) expanding ( https://github.com/stastnypremysl/curly-expander )
curve25519 : Fast implementations of the curve25519 elliptic curve primitives ( https://github.com/acw/curve25519 )
cyclotomic : A subfield of the complex numbers for exact calculation ( https://hackage.haskell.org/package/cyclotomic )
czipwith : CZipWith class and deriving via TH ( https://github.com/lspitzner/czipwith/ )
daemons : Daemons in Haskell made fun and easy ( https://github.com/scvalex/daemons )
data-accessor : Utilities for accessing and manipulating fields of records ( https://www.haskell.org/haskellwiki/Record_access )
data-accessor-mtl : Use Accessor to access state in mtl State monad class ( https://www.haskell.org/haskellwiki/Record_access )
data-accessor-template : Utilities for accessing and manipulating fields of records ( https://www.haskell.org/haskellwiki/Record_access )
data-accessor-transformers : Use Accessor to access state in transformers State monad ( https://www.haskell.org/haskellwiki/Record_access )
data-array-byte : Compatibility layer for Data.Array.Byte ( https://github.com/Bodigrim/data-array-byte )
data-binary-ieee754 : Parser/Serialiser for IEEE-754 floating-point values ( https://john-millikin.com/software/data-binary-ieee754/ )
data-bword : Extra operations on binary words of fixed length ( https://github.com/mvv/data-bword )
data-checked : Type-indexed runtime-checked properties ( https://github.com/mvv/data-checked )
data-clist : Simple functional ring type ( https://github.com/sw17ch/data-clist )
data-default : A class for types with a default value ( https://hackage.haskell.org/package/data-default )
data-default-class : A class for types with a default value ( https://hackage.haskell.org/package/data-default-class )
data-default-instances-base : Default instances for types in base ( https://hackage.haskell.org/package/data-default-instances-base )
data-default-instances-containers : Default instances for types in containers ( https://hackage.haskell.org/package/data-default-instances-containers )
data-default-instances-dlist : Default instances for types in dlist ( https://hackage.haskell.org/package/data-default-instances-dlist )
data-default-instances-old-locale : Default instances for types in old-locale ( https://hackage.haskell.org/package/data-default-instances-old-locale )
data-dword : Stick two binary words together to get a bigger one ( https://github.com/mvv/data-dword )
data-endian : Endian-sensitive data ( https://github.com/mvv/data-endian )
data-fix : Fixpoint data types ( https://github.com/spell-music/data-fix )
data-flags : A package for working with bit masks and flags in general ( https://github.com/mvv/data-flags )
data-hash : Combinators for building fast hashing functions ( https://hackage.haskell.org/package/data-hash )
data-inttrie : A lazy, infinite trie of integers ( https://github.com/luqui/data-inttrie )
data-lens : Used to be Haskell 98 Lenses ( https://github.com/roconnor/data-lens/ )
data-lens-ixset : A Lens for IxSet ( https://github.com/dag/data-lens-ixset )
data-lens-light : Simple lenses, minimum dependencies ( https://github.com/feuerbach/data-lens-light )
data-lens-template : Utilities for Data.Lens ( https://github.com/roconnor/data-lens-template/ )
data-memocombinators : Combinators for building memo tables ( https://github.com/luqui/data-memocombinators )
data-ordlist : Set and bag operations on ordered lists ( https://hackage.haskell.org/package/data-ordlist )
data-pprint : Prettyprint and compare Data values ( https://hackage.haskell.org/package/data-pprint )
data-reify : Reify a recursive data structure into an explicit graph ( https://ku-fpg.github.io/software/data-reify/ )
data-serializer : Common API for serialization libraries ( https://github.com/mvv/data-serializer )
data-textual : Human-friendly textual representations ( https://github.com/mvv/data-textual )
data-tree-print : Print Data instances as a nested tree ( https://github.com/lspitzner/data-tree-print )
dataenc : Data encoding library ( https://www.haskell.org/haskellwiki/Library/Data_encoding )
date-cache : Date cacher ( https://hackage.haskell.org/package/date-cache )
dates : Small library for parsing different dates formats ( https://github.com/portnov/dates )
datetime : Utilities to make Data.Time.* easier to use ( https://github.com/stackbuilders/datetime )
dbus : A client library for the D-Bus IPC system ( https://github.com/rblaze/haskell-dbus#readme )
dbus-hslogger : Expose a dbus server to control hslogger ( https://github.com/IvanMalison/dbus-hslogger#readme )
decimal : Decimal numbers with variable precision ( https://github.com/PaulJohnson/Haskell-Decimal )
deepseq-generics : GHC.Generics-based Control.DeepSeq.rnf implementation ( https://github.com/hvr/deepseq-generics )
deferred-folds : Abstractions over deferred folds ( https://github.com/nikita-volkov/deferred-folds )
dense-linear-algebra : Simple and incomplete pure haskell implementation of linear algebra ( https://hackage.haskell.org/package/dense-linear-algebra )
dependent-map : Dependent finite maps (partial dependent products) ( https://github.com/obsidiansystems/dependent-map )
dependent-sum : Dependent sum type ( https://github.com/obsidiansystems/dependent-sum )
dependent-sum-template : Template Haskell code to generate instances of classes in dev-haskell/some ( https://github.com/obsidiansystems/dependent-sum-template )
derive-storable : Derive Storable instances with GHC.Generics ( https://www.github.com/mkloczko/derive-storable/ )
derive-storable-plugin : GHC core plugin supporting the derive-storable package ( https://www.github.com/mkloczko/derive-storable-plugin/ )
deriving-aeson : Type driven generic aeson instance customisation ( https://hackage.haskell.org/package/deriving-aeson )
deriving-compat : Backports of GHC deriving extensions ( https://github.com/haskell-compat/deriving-compat )
descriptive : Self-describing consumers/parsers; forms, cmd-line args, JSON, etc ( https://github.com/chrisdone/descriptive )
df1 : Type, render and parse the df1 hierarchical structured log format ( https://github.com/k0001/di )
di : Typeful hierarchical structured logging using di, mtl and df1 ( https://github.com/k0001/di )
di-core : Typeful hierarchical structured logging without monad towers ( https://github.com/k0001/di )
di-df1 : Write logs in the df1 format using the di logging framework ( https://github.com/k0001/di )
di-handle : IO support for file handles in di-core ( https://github.com/k0001/di )
di-monad : mtl flavoured typeful hierarchical structured logging for di-core ( https://github.com/k0001/di )
di-polysemy : DI logger wrapped for Polysemy ( https://github.com/nitros12/di-polysemy )
diagrams : Embedded domain-specific language for declarative vector graphics ( https://diagrams.github.io )
diagrams-builder : hint-based build service for the diagrams graphics EDSL ( https://diagrams.github.io )
diagrams-cairo : Cairo backend for diagrams drawing EDSL ( https://diagrams.github.io )
diagrams-canvas : HTML5 canvas backend for diagrams drawing EDSL ( http://projects.haskell.org/diagrams/ )
diagrams-contrib : Collection of user contributions to diagrams EDSL ( https://diagrams.github.io/ )
diagrams-core : Core libraries for diagrams EDSL ( https://diagrams.github.io )
diagrams-gtk : Backend for rendering diagrams directly to GTK windows ( http://projects.haskell.org/diagrams/ )
diagrams-lib : Embedded domain-specific language for declarative graphics ( https://diagrams.github.io )
diagrams-pgf : PGF backend for diagrams drawing EDSL ( https://github.com/cchalmers/diagrams-pgf )
diagrams-postscript : Postscript backend for diagrams drawing EDSL ( https://diagrams.github.io/ )
diagrams-rasterific : Rasterific backend for diagrams ( https://projects.haskell.org/diagrams/ )
diagrams-solve : Pure Haskell solver routines used by diagrams ( https://projects.haskell.org/diagrams )
diagrams-svg : SVG backend for diagrams drawing EDSL ( https://diagrams.github.io/ )
dice : Simplistic DandD style dice-rolling system ( https://hackage.haskell.org/package/dice )
dictionary-sharing : Sharing/memoization of class members ( https://hackage.haskell.org/package/dictionary-sharing )
diff : O(ND) diff algorithm in haskell ( https://hackage.haskell.org/package/Diff )
diffarray : This package defines the DiffArray type ( https://hackage.haskell.org/package/diffarray )
digest : Various cryptographic hashes for bytestrings; CRC32 and Adler32 for now ( https://hackage.haskell.org/package/digest )
digestive-functors : A practical formlet library ( https://github.com/jaspervdj/digestive-functors )
digestive-functors-blaze : Blaze frontend for the digestive-functors library ( https://github.com/jaspervdj/digestive-functors )
digestive-functors-happstack : Happstack backend for the digestive-functors library ( https://github.com/jaspervdj/digestive-functors )
digestive-functors-snap : Snap backend for the digestive-functors library ( https://github.com/jaspervdj/digestive-functors )
digits : Converts integers to lists of digits and back ( https://hackage.haskell.org/package/digits )
dimensional : Statically checked physical dimensions, using Type Families and Data Kinds ( https://github.com/bjornbm/dimensional/ )
dimensions : Safe type-level dimensionality for multidimensional data ( https://github.com/achirkin/easytensor#readme )
dir-traverse : Simple directory traversal library ( https://hackage.haskell.org/package/dir-traverse )
direct-sqlite : Low-level binding to SQLite3. Includes UTF8 and BLOB support ( https://github.com/IreneKnapp/direct-sqlite )
directory-layout : Directory layout DSL ( https://hackage.haskell.org/package/directory-layout )
directory-listing-webpage-parser : directory listing webpage parser ( https://hackage.haskell.org/package/directory-listing-webpage-parser )
directory-tree : A simple directory-like tree datatype, with useful IO functions ( http://brandon.si/code/directory-tree-module-released/ )
disassembler : Disassembler for X86 and AMD64 machine code ( https://github.com/mgrabmueller/disassembler )
discord-haskell : Write bots for Discord in Haskell ( https://github.com/discord-haskell/discord-haskell )
disk-free-space : Retrieve information about disk space usage ( https://github.com/redneb/disk-free-space )
distributed-static : Compositional, type-safe, polymorphic static values and closures ( http://haskell-distributed.github.com )
distributive : Distributive functors -- Dual to Traversable ( https://github.com/ekmett/distributive/ )
djinn : Generate Haskell code from a type ( https://hackage.haskell.org/package/djinn )
djinn-ghc : Generate Haskell code from a type. Bridge from Djinn to GHC API ( https://hackage.haskell.org/package/djinn-ghc )
djinn-lib : Generate Haskell code from a type. Library extracted from djinn package ( http://www.augustsson.net/Darcs/Djinn/ )
djot : Parser and renderer for djot light markup syntax ( https://hackage.haskell.org/package/djot )
dlist-instances : Difference lists instances ( https://github.com/gregwebs/dlist-instances )
doclayout : A prettyprinting library for laying out text documents ( https://github.com/jgm/doclayout )
docopt : A command-line interface parser that will make you smile ( https://github.com/docopt/docopt.hs )
doctemplates : Pandoc-style document templates ( https://github.com/jgm/doctemplates#readme )
doctest : Test interactive Haskell examples ( https://github.com/sol/doctest#readme )
doctest-discover : Easy way to run doctests via cabal ( https://github.com/karun012/doctest-discover )
doctest-driver-gen : Generate driver file for doctest's cabal integration ( https://github.com/Hexirp/doctest-driver-gen#readme )
doctest-parallel : Test interactive Haskell examples ( https://github.com/martijnbastiaan/doctest-parallel#readme )
dotenv : Loads environment variables from dotenv files ( https://github.com/stackbuilders/dotenv-hs )
dotgen : A simple interface for building .dot graph files ( https://github.com/ku-fpg/dotgen )
double-conversion : Fast conversion between single and double precision floating point and text ( https://github.com/haskell/double-conversion )
download-curl : High-level file download based on URLs ( http://code.haskell.org/~dons/code/download-curl )
drbg : Deterministic random bit generator (aka PRNG) based HMACs, Hashes, and Ciphers ( https://hackage.haskell.org/package/DRBG )
dsp : Haskell Digital Signal Processing ( https://www.haskell.org/haskellwiki/DSP )
dual-tree : Rose trees with cached and accumulating monoidal annotations ( https://hackage.haskell.org/package/dual-tree )
dynamic-graph : Draw and update graphs in real time with OpenGL ( https://github.com/adamwalker/dynamic-graph )
dynamic-state : Optionally serializable dynamic state keyed by type ( https://hackage.haskell.org/package/dynamic-state )
dyre : Dynamic reconfiguration in Haskell ( https://github.com/willdonnelly/dyre )
easy-file : Cross-platform File handling ( https://github.com/kazu-yamamoto/easy-file )
easyrender : User-friendly creation of EPS, PostScript, and PDF files ( http://www.mathstat.dal.ca/~selinger/easyrender/ )
echo : A cross-platform, cross-console way to handle echoing terminal input ( https://github.com/RyanGlScott/echo )
ed25519 : Ed25519 cryptographic signatures ( https://thoughtpolice.github.com/hs-ed25519 )
ede : Templating language with similar syntax and features to Liquid or Jinja2 ( https://github.com/brendanhay/ede )
edisonapi : A library of efficient, purely-functional data structures (API) ( http://rwd.rdockins.name/edison/home/ )
edit-distance : Levenshtein and restricted Damerau-Levenshtein edit distances ( https://github.com/phadej/edit-distance )
edit-distance-vector : Calculate edit distances and edit scripts between vectors ( https://github.com/thsutton/edit-distance-vector )
editline : Bindings to the editline library (libedit) ( http://code.haskell.org/editline )
editor-open : Open the user's \$VISUAL or \$EDITOR for text input ( https://github.com/pharpend/editor-open )
egison : Programming language with non-linear pattern-matching against non-free data ( http://www.egison.org )
either : Combinators for working with sums ( https://github.com/ekmett/either/ )
either-unwrap : Functions for probing and unwrapping values inside of Either ( https://github.com/gcross/either-unwrap )
email-validate : Email address validation ( https://github.com/Porges/email-validate-hs )
emoji : emoji utility ( https://github.com/nakaji-dayo/hs-emoji#readme )
emojis : Conversion between emoji characters and their names ( https://github.com/jgm/emojis#readme )
enclosed-exceptions : Catching all exceptions from within an enclosed computation ( https://github.com/jcristovao/enclosed-exceptions )
entropy : A platform independent entropy source ( https://github.com/TomMD/entropy )
enumerator : Reliable, high-performance processing with left-fold enumerators ( https://john-millikin.com/software/enumerator/ )
enummapset : IntMap and IntSet with Enum keys/elements ( https://github.com/Mikolaj/enummapset )
enumset : Sets of enumeration values represented by machine words ( https://hackage.haskell.org/package/enumset )
env-locale : A (non-forking) interface to the current locale ( https://github.com/Ongy/locale-hs )
equivalence : Maintaining an equivalence relation implemented as union-find using STT ( https://github.com/pa-ba/equivalence )
erf : The error function, erf, and related functions ( https://hackage.haskell.org/package/erf )
errorcall-eq-instance : An orphan Eq instance for ErrorCall ( https://hackage.haskell.org/package/errorcall-eq-instance )
errors : Simplified error-handling ( https://hackage.haskell.org/package/errors )
esqueleto : Type-safe EDSL for SQL queries on persistent backends ( https://github.com/bitemyapp/esqueleto )
etherbunny : A network analysis toolkit for Haskell ( http://etherbunny.anytini.com/ )
event-list : Event lists with relative or absolute time stamps ( http://code.haskell.org/~thielema/event-list/ )
exact-pi : Exact rational multiples of pi (and integer powers of pi) ( https://github.com/dmcclean/exact-pi/ )
exception-mtl : Exception monad transformer instances for mtl classes ( https://hackage.haskell.org/package/exception-mtl )
exception-transformers : Type classes and monads for unchecked extensible exceptions ( https://hackage.haskell.org/package/exception-transformers )
exceptions : Extensible optionally-pure exceptions ( https://github.com/ekmett/exceptions/ )
executable-path : Finding out the full path of the executable ( http://code.haskell.org/~bkomuves/ )
exif : A Haskell binding to a subset of libexif ( https://hackage.haskell.org/package/exif )
explicit-exception : Exceptions which are explicit in the type signature ( https://wiki.haskell.org/Exception )
extensible : Extensible, efficient, optics-friendly data types and effects ( https://github.com/fumieval/extensible )
extensible-effects : An Alternative to Monad Transformers ( https://github.com/suhailshergill/extensible-effects )
extensible-exceptions : Extensible exceptions ( https://hackage.haskell.org/package/extensible-exceptions )
extensions : Parse Haskell Language Extensions ( https://github.com/kowainik/extensions )
extra : Extra functions I use ( https://github.com/ndmitchell/extra#readme )
fail : Forward-compatible MonadFail class ( https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail )
failure : A simple type class for success/failure computations. (deprecated) ( https://www.haskell.org/haskellwiki/Failure )
fast-builder : Fast ByteString Builder ( https://github.com/takano-akio/fast-builder )
fast-logger : A fast logging system ( https://github.com/kazu-yamamoto/logger )
fast-math : Non IEEE-754 compliant compile-time floating-point optimisations ( https://hackage.haskell.org/package/fast-math )
fastcgi : A Haskell library for writing FastCGI programs ( https://hackage.haskell.org/package/fastcgi )
fclabels : First class accessor labels implemented as lenses ( https://github.com/sebastiaanvisser/fclabels )
fdo-notify : Desktop Notifications client ( http://bitbucket.org/taejo/fdo-notify/ )
fdo-trash : Utilities related to freedesktop Trash standard ( https://github.com/jkarlson/fdo-trash )
fec : Forward error correction of ByteStrings ( https://allmydata.org/source/zfec )
feed : Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds ( https://github.com/haskell-party/feed )
fficxx : automatic C++ binding generation ( https://hackage.haskell.org/package/fficxx )
ffmpeg-light : Minimal bindings to the FFmpeg library ( https://github.com/acowley/ffmpeg-light )
fft : Bindings to the FFTW library ( https://hackage.haskell.org/package/fft )
fgl : Martin Erwig's Functional Graph Library ( https://hackage.haskell.org/package/fgl )
fgl-arbitrary : QuickCheck support for fgl ( https://hackage.haskell.org/package/fgl-arbitrary )
fgl-visualize : Convert FGL graphs to dot (graphviz) files ( https://hackage.haskell.org/package/fgl-visualize )
file-embed : Use Template Haskell to embed file contents directly ( https://github.com/snoyberg/file-embed )
file-embed-lzma : Use Template Haskell to embed (LZMA compressed) data ( https://github.com/phadej/file-embed-lzma )
file-location : common functions that show file location information ( https://github.com/gregwebs/FileLocation.hs )
file-modules : Takes a Haskell source-code file and outputs its modules ( https://github.com/yamadapc/stack-run-auto )
filelock : Portable interface to file locking (flock / LockFileEx) ( https://github.com/haskell-pkg-janitors/filelock )
filemanip : Expressive file and directory manipulation for Haskell ( https://github.com/bos/filemanip )
filepath-bytestring : Library for manipulating RawFilePaths in a cross platform way ( https://hackage.haskell.org/package/filepath-bytestring )
filepattern : File path glob-like matching ( https://github.com/ndmitchell/filepattern#readme )
filestore : Interface for versioning file stores ( https://hackage.haskell.org/package/filestore )
fin : Nat and Fin: peano naturals and finite numbers ( https://github.com/phadej/vec )
findbin : Locate directory of original program ( https://github.com/audreyt/findbin )
fingertree : Generic finger-tree structure, with example instances ( https://hackage.haskell.org/package/fingertree )
finite-field : Finite Fields ( https://hackage.haskell.org/package/finite-field )
finite-typelits : A type inhabited by finitely many values, indexed by type-level naturals ( https://github.com/mniip/finite-typelits )
first-class-families : First-class type families ( https://github.com/Lysxia/first-class-families#readme )
fix-agda-whitespace : Fixes whitespace issues for Agda sources ( https://hackage.haskell.org/package/fix-agda-whitespace )
fixed : Signed 15.16 precision fixed point arithmetic ( https://github.com/ekmett/fixed )
fixed-vector : Generic vectors with statically known size ( https://hackage.haskell.org/package/fixed-vector )
fixed-vector-hetero : Generic heterogeneous vectors ( http://github.org/Shimuuar/fixed-vector-hetero )
fixplate : Uniplate-style generic traversals for optionally annotated fixed-point types ( http://code.haskell.org/~bkomuves/ )
flac : Complete high-level binding to libFLAC ( https://github.com/mrkkrp/flac )
flac-picture : Support for writing picture to FLAC metadata blocks with JuicyPixels ( https://github.com/mrkkrp/flac-picture )
flexible-defaults : Generate default function implementations for complex type classes ( https://github.com/peti/flexible-defaults )
floatinghex : Read and write hexadecimal floating point numbers ( https://hackage.haskell.org/package/FloatingHex )
floskell : A flexible Haskell source code pretty printer ( https://github.com/ennocramer/floskell )
flow2dot : Library and binary to generate sequence/flow diagrams from plain text source ( https://github.com/adept/flow2dot )
focus : A general abstraction for manipulating elements of container data structures ( https://github.com/nikita-volkov/focus )
focuslist : Lists with a focused element ( https://github.com/cdepillabout/focuslist )
foldable1-classes-compat : Compatibility package for the Foldable1 and Bifoldable1 type classes ( https://github.com/haskell-compat/foldable1-classes-compat )
foldl : Composable, streaming, and efficient left folds ( https://hackage.haskell.org/package/foldl )
follow-file : Be notified when a file gets appended, solely with what was added ( https://github.com/athanclark/follow-file#readme )
fontyfruity : A true type file format loader ( https://hackage.haskell.org/package/FontyFruity )
force-layout : Simple force-directed layout ( https://hackage.haskell.org/package/force-layout )
foreign-store : Store a stable pointer in a foreign context to be retrieved later ( https://github.com/chrisdone/foreign-store )
formatting : Combinator-based type-safe formatting (like printf() or FORMAT) ( https://github.com/AJChapman/formatting#readme )
foundation : Alternative prelude with batteries and no dependencies ( https://github.com/haskell-foundation/foundation )
fourmolu : A formatter for Haskell source code ( https://github.com/fourmolu/fourmolu )
fpretty : Efficient simple pretty printing combinators ( http://www.cs.kent.ac.uk/~oc/pretty.html )
freer : Implementation of the Freer Monad ( https://gitlab.com/queertypes/freer )
freer-effects : Implementation of effect system for Haskell ( https://github.com/IxpertaSolutions/freer-effects )
fresco-binding : Fresco binding for Haskell ( https://hackage.haskell.org/package/fresco-binding )
frisby : Linear time composable parser for PEG grammars ( http://repetae.net/computer/frisby/ )
from-sum : Canonical fromMaybeM and fromEitherM functions ( https://github.com/cdepillabout/from-sum )
fsnotify : Cross platform library for file change notification ( https://github.com/haskell-fswatch/hfsnotify )
fst : Finite state transducers ( http://www.cse.chalmers.se/alumni/markus/fstStudio/ )
ftgl : Portable TrueType font rendering for OpenGL using the Freetype2 library ( https://hackage.haskell.org/package/FTGL )
functor-classes-compat : Data.Functor.Classes instances for core packages ( https://github.com/phadej/functor-classes-compat#readme )
functor-monadic : Monad-style combinators for functors ( https://github.com/ombocomp/FunctorMonadic/ )
fusion-plugin : GHC plugin to make stream fusion more predictable ( https://github.com/composewell/fusion-plugin )
fusion-plugin-types : Types for the fusion-plugin package ( https://github.com/composewell/fusion-plugin-types )
fuzzy : Filters a list based on a fuzzy string search ( https://github.com/joom/fuzzy )
gamma : Gamma function and related functions ( https://github.com/rockbmb/gamma2 )
gargoyle : Automatically spin up and spin down local daemons ( https://hackage.haskell.org/package/gargoyle )
gargoyle-postgresql : Manage PostgreSQL servers with gargoyle ( https://hackage.haskell.org/package/gargoyle-postgresql )
gargoyle-postgresql-connect : Connect to gargoyle-managed postgresql instances ( https://hackage.haskell.org/package/gargoyle-postgresql-connect )
gargoyle-postgresql-nix : Manage PostgreSQL servers with gargoyle and nix ( https://hackage.haskell.org/package/gargoyle-postgresql-nix )
gasp : A framework of algebraic classes ( https://hackage.haskell.org/package/gasp )
gauge : small framework for performance measurement and analysis ( https://github.com/vincenthz/hs-gauge )
gd : A Haskell binding to a subset of the GD graphics library ( https://hackage.haskell.org/package/gd )
generic-arbitrary : Generic implementation for QuickCheck's Arbitrary ( https://github.com/typeable/generic-arbitrary#readme )
generic-data : Deriving instances with GHC.Generics and related utilities ( https://github.com/Lysxia/generic-data#readme )
generic-deriving : Generic programming library for generalised deriving ( https://github.com/dreixel/generic-deriving )
generic-lens : Generically derive traversals, lenses and prisms ( https://github.com/kcsongor/generic-lens )
generic-lens-core : Generically derive traversals, lenses and prisms ( https://github.com/kcsongor/generic-lens )
generic-lens-labels : GHC.OverloadedLabels.IsLabel instance for lenses from ghc-generics ( https://github.com/duog/generic-lens-labels )
generic-monoid : Derive monoid instances for product types ( https://hackage.haskell.org/package/generic-monoid )
generic-random : Generic random generators ( https://github.com/lysxia/generic-random )
generic-trie : A map, where the keys may be complex structured data ( https://github.com/glguy/tries )
generically : Generically newtype to use with DerivingVia ( https://hackage.haskell.org/package/generically )
genericpretty : A generic, derivable, haskell pretty printer ( https://github.com/RazvanRanca/GenericPretty )
generics-sop : Generic Programming using True Sums of Products ( https://hackage.haskell.org/package/generics-sop )
geniplate-mirror : Use Template Haskell to generate Uniplate-like functions ( https://github.com/danr/geniplate )
genvalidity : Testing utilities for the validity library ( https://github.com/NorfairKing/validity#readme )
genvalidity-aeson : GenValidity support for aeson ( https://github.com/NorfairKing/validity#readme )
genvalidity-containers : GenValidity support for containers ( https://github.com/NorfairKing/validity#readme )
genvalidity-hspec : Standard spec's for GenValidity instances ( https://github.com/NorfairKing/validity#readme )
genvalidity-hspec-aeson : Standard spec's for aeson-related instances ( https://cs-syd.eu )
genvalidity-path : GenValidity support for Path ( https://github.com/NorfairKing/validity#readme )
genvalidity-property : Standard properties for functions on 'Validity' types ( https://github.com/NorfairKing/validity#readme )
genvalidity-scientific : GenValidity support for Scientific ( https://github.com/NorfairKing/validity#readme )
genvalidity-text : GenValidity support for Text ( https://github.com/NorfairKing/validity#readme )
genvalidity-unordered-containers : GenValidity support for unordered-containers ( https://github.com/NorfairKing/validity#readme )
genvalidity-vector : GenValidity support for vector ( https://github.com/NorfairKing/validity#readme )
getopt-generics : Create command line interfaces with ease ( https://github.com/soenkehahn/getopt-generics#readme )
ghc-api-compat : GHC-API compatibility helpers ( https://hackage.haskell.org/package/ghc-api-compat )
ghc-byteorder : \"GHC.ByteOrder\" API Compatibility Layer ( http://hackage.haskell.org/package/ghc-byteorder )
ghc-check : detect mismatches between compile-time and run-time versions of the ghc api ( https://hackage.haskell.org/package/ghc-check )
ghc-core : Display GHC's core and assembly output in a pager ( https://github.com/shachaf/ghc-core )
ghc-datasize : Determine the size of data structures in GHC's memory ( http://felsin9.de/nnis/ghc-datasize )
ghc-events : Library and tool for parsing .eventlog files from GHC ( https://hackage.haskell.org/package/ghc-events )
ghc-exactprint : ExactPrint for GHC ( https://hackage.haskell.org/package/ghc-exactprint )
ghc-gc-tune : Graph performance of Haskell programs with different GC flags ( https://github.com/ulysses4ever/ghc-gc-tune#readme )
ghc-heap-view : Extract the heap representation of Haskell values and thunks ( https://hackage.haskell.org/package/ghc-heap-view )
ghc-lib : The GHC API, decoupled from GHC versions ( https://github.com/digital-asset/ghc-lib )
ghc-lib-parser : The GHC API, decoupled from GHC versions ( https://github.com/digital-asset/ghc-lib )
ghc-lib-parser-ex : Algorithms on GHC parse trees ( https://github.com/shayne-fletcher/ghc-lib-parser-ex#readme )
ghc-parser : Haskell source parser from GHC ( https://github.com/gibiansky/IHaskell )
ghc-paths : Knowledge of GHC's installation directories ( https://hackage.haskell.org/package/ghc-paths )
ghc-prof : Library for parsing GHC time and allocation profiling reports ( https://github.com/maoe/ghc-prof )
ghc-prof-aeson : Parser for GHC's JSON profiling output ( https://github.com/Fuuzetsu/ghc-prof-aeson#readme )
ghc-prof-aeson-flamegraph : Turn GHC '-pj' profiling output into FlameGraph format ( https://github.com/Fuuzetsu/ghc-prof-aeson-flamegraph#readme )
ghc-source-gen : Constructs Haskell syntax trees for the GHC API ( https://github.com/google/ghc-source-gen#readme )
ghc-tcplugins-extra : Utilities for writing GHC type-checker plugins ( https://github.com/clash-lang/ghc-tcplugins-extra#readme )
ghc-trace-events : Faster traceEvent and traceMarker, and binary object logging for eventlog ( https://github.com/maoe/ghc-trace-events )
ghc-typelits-extra : Additional type-level operations on GHC.TypeLits.Nat ( https://www.clash-lang.org/ )
ghc-typelits-knownnat : Derive KnownNat constraints from other KnownNat constraints ( https://clash-lang.org/ )
ghc-typelits-natnormalise : GHC typechecker plugin for types of kind GHC.TypeLits.Nat ( https://www.clash-lang.org/ )
ghci-pretty : colored pretty-printing within ghci ( https://github.com/larskuhtz/ghci-pretty )
ghcid : GHCi based bare bones IDE ( https://github.com/ndmitchell/ghcid#readme )
ghcide : The core of an IDE ( https://github.com/haskell/haskell-language-server/tree/master/ghcide#readme )
ghcide-test-utils : Test utils for ghcide ( https://github.com/haskell/haskell-language-server/tree/master/ghcide#readme )
ghcjs-codemirror : Installs CodeMirror JavaScript files ( https://github.com/ghcjs/CodeMirror )
gi-cairo : Cairo bindings ( https://github.com/haskell-gi/haskell-gi )
gi-cairo-connector : GI friendly Binding to the Cairo library ( https://github.com/cohomology/gi-cairo-render )
gi-cairo-render : GI friendly Binding to the Cairo library ( https://github.com/cohomology/gi-cairo-render )
gi-dbusmenu : Dbusmenu bindings ( https://github.com/haskell-gi/haskell-gi )
gi-dbusmenugtk3 : DbusmenuGtk bindings ( https://github.com/haskell-gi/haskell-gi )
gi-freetype2 : freetype2 bindings ( https://github.com/haskell-gi/haskell-gi )
gi-gdkpixbuf : GdkPixbuf bindings ( https://github.com/haskell-gi/haskell-gi )
gi-gdkx11 : GdkX11 bindings ( https://github.com/haskell-gi/haskell-gi )
gi-glib : GLib bindings ( https://github.com/haskell-gi/haskell-gi )
gi-gmodule : GModule bindings ( https://github.com/haskell-gi/haskell-gi )
gi-gobject : GObject bindings ( https://github.com/haskell-gi/haskell-gi )
gi-graphene : Graphene bindings ( https://github.com/haskell-gi/haskell-gi )
gi-gst : GStreamer bindings ( https://github.com/haskell-gi/haskell-gi )
gi-gstbase : GStreamerBase bindings ( https://github.com/haskell-gi/haskell-gi )
gi-gstvideo : GStreamerVideo bindings ( https://github.com/haskell-gi/haskell-gi )
gi-gtk-hs : A wrapper for gi-gtk, adding a few more idiomatic API parts on top ( https://github.com/haskell-gi/haskell-gi )
gi-gtksource : GtkSource bindings ( https://github.com/haskell-gi/haskell-gi )
gi-harfbuzz : HarfBuzz bindings ( https://github.com/haskell-gi/haskell-gi )
gi-javascriptcore : JavaScriptCore bindings ( https://github.com/haskell-gi/haskell-gi )
gi-pango : Pango bindings ( https://github.com/haskell-gi/haskell-gi )
gi-soup : Libsoup bindings ( https://github.com/haskell-gi/haskell-gi )
gi-vte : Vte bindings ( https://github.com/haskell-gi/haskell-gi )
gi-webkit2 : WebKit2 bindings ( https://github.com/haskell-gi/haskell-gi )
gi-xlib : xlib bindings ( https://github.com/haskell-gi/haskell-gi )
ginger : An implementation of the Jinja2 template language in Haskell ( https://ginger.tobiasdammers.nl/ )
git : Git operations in haskell ( https://github.com/vincenthz/hs-git )
git-lfs : git-lfs protocol ( https://hackage.haskell.org/package/git-lfs )
githash : Compile git revision info into Haskell projects ( https://github.com/snoyberg/githash#readme )
github : Access to the GitHub API, v3 ( https://github.com/haskell-github/github )
gitrev : Compile git revision info into Haskell projects ( https://github.com/acfoltzer/gitrev )
gl : Complete OpenGL raw bindings ( https://hackage.haskell.org/package/gl )
glambda : A simply typed lambda calculus interpreter, written with GADTs ( https://github.com/goldfirere/glambda )
glfw : A Haskell binding for GLFW ( http://haskell.org/haskellwiki/GLFW )
glfw-b : Bindings to GLFW OpenGL library ( https://hackage.haskell.org/package/GLFW-b )
glib : Binding to the GLIB library for Gtk2Hs ( https://projects.haskell.org/gtk2hs/ )
gloss : Painless 2D vector graphics, animations and simulations ( https://gloss.ouroborus.net )
gloss-algorithms : Data structures and algorithms for working with 2D graphics ( http://gloss.ouroborus.net )
gloss-examples : Examples using the gloss library ( https://gloss.ouroborus.net )
gloss-juicy : Load any image supported by Juicy.Pixels in your gloss application ( https://github.com/hpacheco/gloss-juicy )
gloss-raster : Parallel rendering of raster images ( http://gloss.ouroborus.net )
gloss-rendering : Gloss picture data types and rendering functions ( https://hackage.haskell.org/package/gloss-rendering )
gluraw : A raw binding for the OpenGL graphics system ( https://www.haskell.org/haskellwiki/Opengl )
glut : A binding for the OpenGL Utility Toolkit ( https://www.haskell.org/haskellwiki/Opengl )
glutil : Miscellaneous OpenGL utilities ( https://hackage.haskell.org/package/GLUtil )
gnuidn : Bindings for GNU IDN ( https://john-millikin.com/software/haskell-gnuidn/ )
gnuplot : 2D and 3D plots using gnuplot ( https://www.haskell.org/haskellwiki/Gnuplot )
gnutls : Bindings for GNU libgnutls ( https://john-millikin.com/software/haskell-gnutls/ )
goa : GHCi bindings to lambdabot ( https://hackage.haskell.org/package/goa )
googlesuggest : Interface to Google Suggest API ( https://hackage.haskell.org/package/GoogleSuggest )
googletranslate : Interface to Google Translate API ( https://hackage.haskell.org/package/GoogleTranslate )
gpipe : Typesafe functional GPU graphics programming ( https://github.com/tobbebex/GPipe-Core#readme )
gpipe-glfw : GLFW OpenGL context creation for GPipe ( https://github.com/plredmond/GPipe-GLFW )
graphmod : Present the module dependencies of a program as a \"dot\" graph ( https://github.com/yav/graphmod/wiki )
graphscc : Tarjan's algorithm for computing the strongly connected components of a graph ( https://hackage.haskell.org/package/GraphSCC )
graphviz : Bindings to Graphviz for graph visualisation ( https://github.com/ivan-m/graphviz )
gravatar : Generate Gravatar image URLs ( https://hackage.haskell.org/package/gravatar )
gridtables : Parser for reStructuredText-style grid tables ( https://github.com/tarleb/gridtables )
groom : Pretty printing for well-behaved Show instances ( https://hackage.haskell.org/package/groom )
groundhog : Type-safe datatype-database mapping library ( https://github.com/lykahb/groundhog )
groundhog-postgresql : PostgreSQL backend for the groundhog library ( https://hackage.haskell.org/package/groundhog-postgresql )
groundhog-sqlite : Sqlite3 backend for the groundhog library ( https://hackage.haskell.org/package/groundhog-sqlite )
groundhog-th : Type-safe datatype-database mapping library ( https://hackage.haskell.org/package/groundhog-th )
groupoids : This package has been absorbed into semigroupoids 4.0 ( https://github.com/ekmett/groupoids/ )
groups : A group is a monoid with invertibility ( https://hackage.haskell.org/package/groups )
gsasl : Bindings for GNU libgsasl ( https://git.sr.ht/~singpolyma/gsasl-haskell )
gtk : Binding to the Gtk+ graphical user interface library ( https://projects.haskell.org/gtk2hs/ )
gtk-serialized-event : GTK+ Serialized event ( https://www.haskell.org/gtk2hs/ )
gtk-strut : Library for creating strut windows with gi-gtk ( https://github.com/IvanMalison/gtk-strut#readme )
gtk-traymanager : A wrapper around the eggtraymanager library for Linux system trays ( https://github.com/travitch/gtk-traymanager )
gtk2hs-buildtools : Tools to build the Gtk2Hs suite of User Interface libraries ( https://projects.haskell.org/gtk2hs/ )
gtk3 : Binding to the Gtk+ 3 graphical user interface library ( https://projects.haskell.org/gtk2hs/ )
gtkglext : Binding to the GTK+ OpenGL Extension ( http://projects.haskell.org/gtk2hs/ )
hackage-db : Access cabal-install's Hackage database via Data.Map ( https://github.com/peti/hackage-db#readme )
hackage-security : Hackage security library ( https://github.com/haskell/hackage-security )
haddock : A documentation-generation tool for Haskell libraries ( https://www.haskell.org/haddock/ )
haddock-api : A documentation-generation tool for Haskell libraries ( https://www.haskell.org/haddock/ )
haddock-library : Library exposing some functionality of Haddock ( https://www.haskell.org/haddock/ )
hadrian : GHC build system ( https://gitlab.haskell.org/ghc/ghc/-/tree/master/hadrian#readme )
haha : A simple library for creating animated ascii art on ANSI terminals ( https://hackage.haskell.org/package/haha )
hakyll : A static website compiler library ( https://jaspervdj.be/hakyll )
hakyll-agda : Wrapper to integrate literate Agda files with Hakyll ( https://github.com/bitonic/hakyll-agda )
hakyll-sass : Hakyll SASS compiler over hsass ( https://github.com/meoblast001/hakyll-sass )
hamilton : Physics on generalized coordinate systems using Hamiltonian Mechanics and AD ( https://github.com/mstksg/hamilton#readme )
hamlet : Haml-like template files that are compile-time checked (deprecated) ( http://www.yesodweb.com/book/shakespearean-templates )
handsomesoup : Work with HTML more easily in HXT ( https://github.com/egonSchiele/HandsomeSoup )
happraise : A small program for counting the comments in haskell source ( https://hackage.haskell.org/package/happraise )
happstack : The haskell application server stack + code generation ( http://happstack.com )
happstack-authenticate : Happstack Authentication Library ( https://www.happstack.com/ )
happstack-hamlet : Support for Hamlet HTML templates in Happstack ( http://www.happstack.com/ )
happstack-hsp : Support for using HSP templates in Happstack ( https://www.happstack.com/ )
happstack-jmacro : Support for using JMacro with Happstack ( https://www.happstack.com/ )
happstack-plugins : The haskell application server stack + reload ( http://happstack.com )
happstack-server : Web related tools and services ( https://happstack.com )
happstack-server-tls : extend happstack-server with https:// support (TLS/SSL) ( https://www.happstack.com/ )
happy : Happy is a parser generator for Haskell ( https://www.haskell.org/happy/ )
harp : HaRP allows pattern-matching with regular expressions ( https://github.com/seereason/harp )
hashable : A class for types that can be converted to a hash value ( https://github.com/haskell-unordered-containers/hashable )
hashable-time : Hashable instances for Data.Time ( https://hackage.haskell.org/package/hashable-time )
hashing : A pure haskell library implements several hash algorithms ( https://github.com/wangbj/hashing )
hashmap : Persistent containers Map and Set based on hashing ( https://github.com/foxik/hashmap )
hashring : Efficient consistent hashing ( https://github.com/mkscrg/hashring )
hashtables : Mutable hash tables in the ST monad ( https://github.com/gregorycollins/hashtables )
haskakafka : Kafka bindings for Haskell ( https://github.com/cosbynator/haskakafka )
haskeline : A command-line interface for user input, written in Haskell ( https://github.com/judah/haskeline )
haskell-exp-parser : Simple parser parser from Haskell to TemplateHaskell expressions ( https://github.com/emilaxelsson/haskell-exp-parser )
haskell-gettext : GetText runtime library implementation in pure Haskell ( https://hackage.haskell.org/package/haskell-gettext )
haskell-gi : Generate Haskell bindings for GObject Introspection capable libraries ( https://github.com/haskell-gi/haskell-gi )
haskell-gi-base : Foundation for libraries generated by haskell-gi ( https://github.com/haskell-gi/haskell-gi )
haskell-gi-overloading : Overloading support for haskell-gi ( https://github.com/haskell-gi/haskell-gi )
haskell-import-graph : create haskell import graph for graphviz ( https://github.com/ncaq/haskell-import-graph#readme )
haskell-language-server : LSP server for GHC ( https://github.com/haskell/haskell-language-server#readme )
haskell-lexer : A fully compliant Haskell 98 lexer ( https://github.com/yav/haskell-lexer )
haskell-mpi : Distributed parallel programming in Haskell using MPI ( https://github.com/bjpop/haskell-mpi )
haskell-qrencode : Haskell bindings for libqrencode ( https://github.com/jamessanders/haskell-qrencode )
haskell-src : Support for manipulating Haskell source code ( https://hackage.haskell.org/package/haskell-src )
haskell-src-exts : Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer ( https://github.com/haskell-suite/haskell-src-exts )
haskell-src-exts-simple : A simplified view on the haskell-src-exts AST ( https://github.com/int-e/haskell-src-exts-simple )
haskell-src-exts-util : Helper functions for working with haskell-src-exts trees ( https://github.com/pepeiborra/haskell-src-exts-util )
haskell-src-meta : Parse source to template-haskell abstract syntax ( https://hackage.haskell.org/package/haskell-src-meta )
haskellnet : Client support for POP3, SMTP, and IMAP ( https://github.com/qnikst/HaskellNet )
haskellnet-ssl : Helpers to connect to SSL/TLS mail servers with HaskellNet ( https://github.com/dpwright/HaskellNet-SSL )
haskey : A transactional, ACID compliant, embeddable key-value store ( https://github.com/haskell-haskey )
haskey-btree : B+-tree implementation in Haskell ( https://github.com/haskell-haskey/haskey-btree )
hasktags : Produces ctags \"tags\" and etags \"TAGS\" files for Haskell programs ( https://github.com/MarcWeber/hasktags )
haspell : Haskell bindings to aspell ( https://github.com/otters/haspell )
hatex : The Haskell LaTeX library ( https://github.com/Daniel-Diaz/HaTeX/blob/master/README.md )
haxml : Utilities for manipulating XML documents ( https://github.com/HaXml/HaXml )
haxr : XML-RPC client and server library ( https://www.haskell.org/haskellwiki/HaXR )
hcg-minus : haskell cg (minus) ( http://rd.slavepianos.org/t/hcg-minus )
hclip : A small cross-platform library for reading and modifying the system clipboard ( https://github.com/jetho/Hclip )
hcodecs : A library to read, write and manipulate MIDI, WAVE, and SoundFont2 files ( http://www-db.informatik.uni-tuebingen.de/team/giorgidze )
hdaemonize : Library to handle the details of writing daemons for UNIX ( https://github.com/unprolix/hdaemonize )
hdbc : Haskell Database Connectivity ( https://github.com/hdbc/hdbc )
hdbc-mysql : MySQL driver for HDBC ( https://github.com/ryantm/hdbc-mysql )
hdbc-odbc : ODBC driver for HDBC ( https://github.com/hdbc/hdbc-odbc )
hdbc-postgresql : PostgreSQL driver for HDBC ( https://github.com/hdbc/hdbc-postgresql )
hdbc-session : Bracketed connection for HDBC ( http://khibino.github.io/haskell-relational-record/ )
hdbc-sqlite3 : Sqlite v3 driver for HDBC ( https://github.com/hdbc/hdbc-sqlite3 )
hdfa : A simple library for representing and minimising DFAs ( https://hackage.haskell.org/package/hDFA )
headed-megaparsec : More informative parser ( https://github.com/nikita-volkov/headed-megaparsec )
heaps : Asymptotically optimal Brodal/Okasaki heaps ( https://github.com/ekmett/heaps/ )
heapsize : Determine the size of runtime data structures ( https://hackage.haskell.org/package/heapsize )
heckle : Jekyll in Haskell (feat. LaTeX) ( https://github.com/2016rshah/heckle )
hedgehog-fn : Function generation for 'hedgehog' ( https://github.com/qfpl/hedgehog-fn )
hedis : Client library for the Redis datastore: supports full command set, pipelining ( https://github.com/informatikr/hedis )
hedis-config : Easy trivial configuration for Redis ( https://bitbucket.org/s9gf4ult/hedis-config )
heist : An Haskell template system supporting both HTML5 and XML ( https://snapframework.com/ )
here : Here docs and interpolated strings via quasiquotation ( https://github.com/tmhedberg/here )
heredoc : multi-line string / here document using QuasiQuotes ( https://hackage.haskell.org/package/heredoc )
heterocephalus : A type-safe template engine for working with front end development tools ( https://github.com/arowM/heterocephalus#readme )
hex : Convert strings into hexadecimal and back ( https://hackage.haskell.org/package/hex )
hexml : XML subset DOM parser ( https://github.com/ndmitchell/hexml#readme )
hexpat : XML parser/formatter based on expat ( https://haskell.org/haskellwiki/Hexpat/ )
hflags : Command line flag parser, very similar to Google's gflags ( https://github.com/errge/hflags )
hformat : Simple Haskell formatting ( https://github.com/mvoidex/hformat )
hfov : Field-of-view calculation for low-resolution 2D raster grids ( https://github.com/nornagon/hfov )
hgal : library for computation automorphism group and canonical labelling of a graph ( https://hackage.haskell.org/package/hgal )
hgamer3d : Toolset for the Haskell Game Programmer ( http://www.hgamer3d.org )
hgdbmi : GDB Machine Interface: program-driven control of GDB ( https://github.com/copton/hgdbmi )
hgl : A simple graphics library based on X11 or Win32 ( https://hackage.haskell.org/package/HGL )
hi : Generate scaffold for cabal project ( https://github.com/fujimura/hi.git#readme )
hi-file-parser : Parser for GHC's hi files ( https://github.com/commercialhaskell/hi-file-parser#readme )
hie-bios : Set up a GHC API session ( https://github.com/haskell/hie-bios )
hie-compat : HIE files for GHC 8.8 and other HIE file backports ( https://github.com/haskell/haskell-language-server/tree/master/hie-compat#readme )
hiedb : Generates a references DB from .hie files ( https://hackage.haskell.org/package/hiedb )
higgledy : Partial types as a type constructor ( https://github.com/i-am-tom/higgledy )
highlighter : source code highlighting ( https://hackage.haskell.org/package/highlighter )
hinotify : Haskell binding to inotify ( https://github.com/kolmodin/hinotify )
hint : A Haskell interpreter built on top of the GHC API ( https://github.com/haskell-hint/hint )
hip : Haskell Image Processing (HIP) Library ( https://github.com/lehins/hip )
hjavascript : HJavaScript is an abstract syntax for a typed subset of JavaScript ( https://hackage.haskell.org/package/HJavaScript )
hjscript : HJScript is a Haskell EDSL for writing JavaScript programs ( http://patch-tag.com/r/nibro/hjscript )
hjsmin : Haskell implementation of a javascript minifier ( https://github.com/erikd/hjsmin )
hledger-lib : A library providing the core functionality of hledger ( https://hledger.org )
hlibev : FFI interface to libev ( https://github.com/aycanirican/hlibev )
hlibgit2 : Low-level bindings to libgit2 ( https://hackage.haskell.org/package/hlibgit2 )
hlibsass : Low-level bindings to Libsass ( https://github.com/jakubfijalkowski/hlibsass )
hlint : Source code suggestions ( https://github.com/ndmitchell/hlint#readme )
hls-alternate-number-format-plugin : Provide Alternate Number Formats plugin for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-alternate-number-format-plugin#readme )
hls-cabal-fmt-plugin : Integration with the cabal-fmt code formatter ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-cabal-fmt-plugin#readme )
hls-cabal-plugin : Cabal integration plugin with Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-cabal-plugin#readme )
hls-call-hierarchy-plugin : Call hierarchy plugin for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-call-hierarchy-plugin#readme )
hls-change-type-signature-plugin : Change a declarations type signature with a Code Action ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-change-type-signature-plugin#readme )
hls-class-plugin : Class/instance management plugin for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-class-plugin#readme )
hls-code-range-plugin : HLS Plugin to support smart selection range and Folding range ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-code-range-plugin#readme )
hls-eval-plugin : Eval plugin for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-eval-plugin#readme )
hls-explicit-fixity-plugin : Show fixity explicitly while hovering ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-explicit-fixity-plugin#readme )
hls-explicit-imports-plugin : Explicit imports plugin for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-explicit-imports-plugin#readme )
hls-explicit-record-fields-plugin : Explicit record fields plugin for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-explicit-record-fields-plugin#readme )
hls-floskell-plugin : Integration with the Floskell code formatter ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-floskell-plugin#readme )
hls-fourmolu-plugin : Integration with the Fourmolu code formatter ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-fourmolu-plugin#readme )
hls-gadt-plugin : Convert to GADT syntax plugin ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-gadt-plugin#readme )
hls-graph : Haskell Language Server internal graph API ( https://github.com/haskell/haskell-language-server#readme )
hls-hlint-plugin : Hlint integration plugin with Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-hlint-plugin#readme )
hls-module-name-plugin : Module name plugin for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-module-name-plugin#readme )
hls-ormolu-plugin : Integration with the Ormolu code formatter ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-ormolu-plugin#readme )
hls-overloaded-record-dot-plugin : Overloaded record dot plugin for Haskell Language Server ( https://hackage.haskell.org/package/hls-overloaded-record-dot-plugin )
hls-plugin-api : Haskell Language Server API for plugin communication ( https://github.com/haskell/haskell-language-server#readme )
hls-pragmas-plugin : Pragmas plugin for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-pragmas-plugin#readme )
hls-qualify-imported-names-plugin : A Haskell Language Server plugin that qualifies imported names ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-qualify-imported-names-plugin#readme )
hls-refactor-plugin : Exactprint refactorings for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-refactor-plugin#readme )
hls-rename-plugin : Rename plugin for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-rename-plugin#readme )
hls-retrie-plugin : Retrie integration plugin for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-retrie-plugin#readme )
hls-semantic-tokens-plugin : Call hierarchy plugin for Haskell Language Server ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-semantic-tokens-plugin#readme )
hls-splice-plugin : HLS Plugin to expand TemplateHaskell Splices and QuasiQuotes ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-splice-plugin#readme )
hls-stylish-haskell-plugin : Integration with the Stylish Haskell code formatter ( https://github.com/haskell/haskell-language-server/tree/master/plugins/hls-stylish-haskell-plugin#readme )
hls-test-utils : Utilities used in the tests of Haskell Language Server ( https://github.com/haskell/haskell-language-server#readme )
hmatrix : Numeric Linear Algebra ( https://github.com/haskell-numerics/hmatrix )
hmatrix-gsl : Numerical computation ( https://github.com/albertoruiz/hmatrix )
hmatrix-gsl-stats : GSL Statistics interface ( http://code.haskell.org/hmatrix-gsl-stats )
hmatrix-vector-sized : Conversions between hmatrix and vector-sized types ( https://github.com/mstksg/hmatrix-vector-sized#readme )
hnix : Haskell implementation of the Nix language ( https://github.com/haskell-nix/hnix#readme )
hnix-store-core : Core effects for interacting with the Nix store ( https://github.com/haskell-nix/hnix-store )
hnix-store-remote : Remote hnix store ( https://github.com/haskell-nix/hnix-store )
hoauth2 : Haskell OAuth2 authentication client ( https://github.com/freizl/hoauth2 )
hogg : Library and tools to manipulate the Ogg container format ( http://www.kfish.org/software/hogg/ )
hood : Debugging by observing in place ( http://ku-fpg.github.io/software/hood )
hookup : Abstraction over creating network connections with SOCKS5 and TLS ( https://github.com/glguy/irc-core )
hoopl : A library to support dataflow analysis and optimization ( https://github.com/haskell/hoopl )
hopfli : Bindings to Google's Zopfli compression library ( https://github.com/ananthakumaran/hopfli )
hora : Convenient type, timestamp, timezone, format ( https://github.com/ciez/hora )
hostname : A a cross-platform means of determining the hostname ( https://hackage.haskell.org/package/hostname )
hourglass : simple performant time related library ( https://github.com/vincenthz/hs-hourglass )
hpack : A modern format for Haskell packages ( https://github.com/sol/hpack#readme )
hpath : Support for well-typed paths ( https://hackage.haskell.org/package/hpath )
hpqtypes : Haskell bindings to libpqtypes ( https://github.com/scrive/hpqtypes )
hprotoc : Parse Google Protocol Buffer specifications ( https://github.com/k-bx/protocol-buffers )
hps : Haskell Postscript ( http://rd.slavepianos.org/?t=hps )
hs-bibutils : Haskell bindings to bibutils, the bibliography conversion utilities ( https://github.com/wilx/hs-bibutils )
hs-duktape : Haskell bindings for a very compact embedded ECMAScript (JavaScript) engine ( https://github.com/myfreeweb/hs-duktape )
hs-java : Java .class files assembler/disassembler ( https://hackage.haskell.org/package/hs-java )
hs3 : Interface to Amazon's Simple Storage Service (S3) ( http://gregheartsfield.com/hS3/ )
hsass : Integrating Sass into Haskell applications ( https://github.com/jakubfijalkowski/hsass )
hsb2hs : Preprocesses a file, adding blobs from files as string literals ( https://hackage.haskell.org/package/hsb2hs )
hscaffold : Very simple file/directory structure scaffolding writer monad EDSL ( https://github.com/yamadapc/hscaffold#readme )
hscolour : Colourise Haskell code ( https://code.haskell.org/~malcolm/hscolour/ )
hscrtmpl : Haskell shell script template ( https://github.com/dino-/hscrtmpl#readme )
hscurses : NCurses bindings for Haskell ( https://github.com/skogsbaer/hscurses )
hse-cpp : Preprocess+parse haskell code ( https://hackage.haskell.org/package/hse-cpp )
hsemail : Parsec parsers for the Internet Message format (e-mail) ( https://github.com/peti/hsemail#readme )
hsexif : EXIF handling library in pure Haskell ( https://github.com/emmanueltouzery/hsexif )
hsh : Library to mix shell scripting with Haskell programs ( http://software.complete.org/hsh )
hsimport : Extend the import list of a Haskell source file ( https://hackage.haskell.org/package/hsimport )
hslogger : Versatile logging framework ( https://github.com/haskell-hvr/hslogger/wiki )
hslua : Bindings to Lua, an embeddable scripting language ( https://hslua.org/ )
hslua-aeson : Allow aeson data types to be used with Lua ( https://hslua.org/ )
hslua-classes : Type classes for HsLua ( https://hslua.org/ )
hslua-cli : Command-line interface for Lua ( https://hslua.org/ )
hslua-core : Bindings to Lua, an embeddable scripting language ( https://hslua.org/ )
hslua-list : Opinionated, but extensible Lua list type ( https://hslua.org/ )
hslua-marshalling : Marshalling of values between Haskell and Lua ( https://hslua.org/ )
hslua-module-doclayout : Lua module wrapping Text.DocLayout ( https://github.com/hslua/hslua-module-doclayout )
hslua-module-path : Lua module to work with file paths ( https://hslua.org/ )
hslua-module-system : Lua module wrapper around Haskell's System module ( https://github.com/hslua/hslua )
hslua-module-text : Lua module for text ( https://github.com/hslua/hslua )
hslua-module-version : Lua module to work with version specifiers ( https://hslua.org/ )
hslua-module-zip : Lua module to work with file zips ( https://hslua.org/ )
hslua-objectorientation : Object orientation tools for HsLua ( https://hslua.org/ )
hslua-packaging : Utilities to build Lua modules ( https://hslua.org/ )
hslua-typing : Type specifiers for Lua ( https://hslua.org/ )
hsndfile : Haskell bindings for libsndfile ( https://haskell.org/haskellwiki/Hsndfile )
hsndfile-vector : Haskell bindings for libsndfile (Data.Vector interface) ( http://haskell.org/haskellwiki/Hsndfile )
hsopenssl : Partial OpenSSL binding for Haskell ( https://github.com/haskell-cryptography/HsOpenSSL )
hsopenssl-x509-system : Use the system's native CA certificate store with HsOpenSSL ( https://github.com/redneb/HsOpenSSL-x509-system )
hsp : Haskell Server Pages is a library for writing dynamic server-side web pages ( http://hub.darcs.net/nibro/hsp )
hsparql : A SPARQL query generator and DSL, and a client to query a SPARQL server ( https://github.com/robstewart57/hsparql )
hspec-api : A Testing Framework for Haskell ( https://hspec.github.io/ )
hspec-attoparsec : Utility functions for testing your attoparsec parsers with hspec ( https://github.com/alpmestan/hspec-attoparsec )
hspec-contrib : Contributed functionality for Hspec ( http://hspec.github.io/ )
hspec-core : A Testing Framework for Haskell ( https://hspec.github.io/ )
hspec-discover : Automatically discover and run Hspec tests ( https://hspec.github.io/ )
hspec-expectations : Catchy combinators for HUnit ( https://github.com/hspec/hspec-expectations#readme )
hspec-expectations-lens : Hspec expectations for the lens stuff ( https://supki.github.io/hspec-expectations-lens/ )
hspec-expectations-lifted : A version of hspec-expectations generalized to MonadIO ( https://hackage.haskell.org/package/hspec-expectations-lifted )
hspec-expectations-pretty-diff : Catchy combinators for HUnit ( https://github.com/myfreeweb/hspec-expectations-pretty-diff#readme )
hspec-golden : Golden tests for hspec ( https://github.com/stackbuilders/hspec-golden#readme )
hspec-hedgehog : Integrate Hedgehog and Hspec! ( https://github.com/parsonsmatt/hspec-hedgehog#readme )
hspec-megaparsec : Utility functions for testing Megaparsec parsers with Hspec ( https://github.com/mrkkrp/hspec-megaparsec )
hspec-meta : A version of Hspec which is used to test Hspec itself ( https://hspec.github.io/ )
hspec-smallcheck : SmallCheck support for the Hspec testing framework ( http://hspec.github.io/ )
hspec-wai : Experimental Hspec support for testing WAI applications ( https://github.com/hspec/hspec-wai#readme )
hspecvariant : Spec for testing properties for variant types ( https://github.com/sanjorgek/hspecVariant )
hsql : Database access from Haskell ( https://hackage.haskell.org/package/hsql )
hsql-mysql : MySQL driver for HSQL ( https://hackage.haskell.org/package/hsql-mysql )
hsql-odbc : A Haskell Interface to ODBC ( https://hackage.haskell.org/package/hsql-odbc )
hsql-sqlite3 : SQLite3 driver for HSQL ( https://hackage.haskell.org/package/hsql-sqlite3 )
hsshellscript : Haskell for Unix shell scripting tasks ( http://www.volker-wysk.de/hsshellscript/ )
hssyck : Fast, lightweight YAML loader and dumper ( https://hackage.haskell.org/package/HsSyck )
hstatistics : Statistics ( http://code.haskell.org/hstatistics )
hstatsd : Quick and dirty statsd interface ( https://github.com/mokus0/hstatsd )
hstringtemplate : StringTemplate implementation in Haskell ( https://hackage.haskell.org/package/HStringTemplate )
hsx-jmacro : hsp+jmacro support ( http://www.happstack.com/ )
hsx2hs : HSX (Haskell Source with XML) allows literal XML syntax in Haskell source code ( https://github.com/seereason/hsx2hs )
hsyaml : Pure Haskell YAML 1.2 processor ( https://github.com/haskell-hvr/HsYAML )
hsyaml-aeson : JSON to YAML Adapter ( https://hackage.haskell.org/package/HsYAML-aeson )
hsyslog : FFI interface to syslog(3) from POSIX.1-2001 ( https://github.com/peti/hsyslog )
htf : The Haskell Test Framework ( https://github.com/skogsbaer/HTF/ )
html : HTML combinator library ( https://hackage.haskell.org/package/html )
html-conduit : Parse HTML documents using xml-conduit datatypes ( https://github.com/snoyberg/xml )
html-entities : A codec library for HTML-escaped text and HTML-entities ( https://github.com/nikita-volkov/html-entities )
html-entity-map : Map from HTML5 entity names to the corresponding Unicode text ( https://github.com/mrkkrp/html-entity-map )
html-parse : A high-performance HTML tokenizer ( https://github.com/bgamari/html-parse )
htoml : Parser for TOML files ( https://github.com/cies/htoml )
htrace : Hierarchical tracing for debugging of lazy evaluation ( https://hackage.haskell.org/package/htrace )
http : A library for client-side HTTP ( https://github.com/haskell/HTTP )
http-api-data : Converting to/from HTTP API data like URL pieces, headers and query parameters ( https://github.com/fizruk/https-api-data )
http-attoparsec : Attoparsec parsers for http-types ( https://github.com/tlaitinen/http-attoparsec )
http-client : An HTTP client engine ( https://github.com/snoyberg/http-client )
http-client-conduit : Frontend support for using http-client with conduit (deprecated) ( https://github.com/snoyberg/http-client )
http-client-multipart : Generate multipart uploads for http-client. (deprecated) ( https://github.com/snoyberg/http-client )
http-client-openssl : http-client backend using the OpenSSL library ( https://github.com/snoyberg/http-client )
http-client-restricted : restricting the servers that http-client will use ( https://hackage.haskell.org/package/http-client-restricted )
http-client-tls : http-client backend using the connection package and tls library ( https://github.com/snoyberg/http-client )
http-common : Common types for HTTP clients and servers ( https://github.com/aesiniath/http-common )
http-conduit : HTTP client package with conduit interface and HTTPS support ( https://github.com/snoyberg/http-client )
http-date : HTTP Date parser/formatter ( https://hackage.haskell.org/package/http-date )
http-download : Verified downloads with retries ( https://github.com/commercialhaskell/http-download#readme )
http-link-header : An RFC 5988 parser and writer for the HTTP Link header ( https://github.com/myfreeweb/http-link-header )
http-media : Processing HTTP Content-Type and Accept headers ( https://github.com/zmthy/http-media )
http-querystring : The HTTP query builder ( https://github.com/worksap-ate/http-querystring )
http-reverse-proxy : Reverse proxy HTTP requests, either over raw sockets or with WAI ( https://github.com/fpco/http-reverse-proxy )
http-streams : An HTTP client using io-streams ( https://github.com/aesiniath/http-streams/ )
http-types : Generic HTTP types for Haskell (for both client and server code) ( https://github.com/Vlix/http-types )
httpd-shed : A simple web-server with an interact style API ( https://hackage.haskell.org/package/httpd-shed )
huffman : Pure Haskell implementation of the Huffman encoding algorithm ( https://hackage.haskell.org/package/huffman )
hunit : A unit testing framework for Haskell ( https://github.com/hspec/HUnit#readme )
hunit-approx : Approximate equality for floating point numbers with HUnit ( https://github.com/goldfirere/HUnit-approx )
hvega : Create Vega-Lite visualizations (version 4) in Haskell ( https://github.com/DougBurke/hvega )
hvega-theme : Theme for hvega ( https://github.com/GregorySchwartz/hvega-theme#readme )
hw-fingertree : Generic finger-tree structure, with example instances ( https://github.com/haskell-works/hw-fingertree#readme )
hw-hspec-hedgehog : Interoperability between hspec and hedgehog ( https://github.com/haskell-works/hw-hspec-hedgehog#readme )
hw-kafka-client : Kafka bindings for Haskell ( https://github.com/haskell-works/hw-kafka-client )
hw-prim : Primitive functions and data types ( https://github.com/haskell-works/hw-prim#readme )
hxt : A collection of tools for processing XML with Haskell ( https://github.com/UweSchmidt/hxt )
hxt-charproperties : Character properties and classes for XML and Unicode ( https://github.com/UweSchmidt/hxt )
hxt-http : Interface to native Haskell HTTP package HTTP ( https://github.com/UweSchmidt/hxt )
hxt-regex-xmlschema : A regular expression library for W3C XML Schema regular expressions ( https://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema )
hxt-unicode : Unicode en-/decoding functions for utf8, iso-latin-* and other encodings ( https://github.com/UweSchmidt/hxt )
hxt-xpath : The XPath modules for HXT ( https://github.com/UweSchmidt/hxt )
hyphenation : Configurable Knuth-Liang hyphenation ( https://github.com/ekmett/hyphenation )
hzenhan : Zenhan library for Haskell ( https://github.com/karky7/hzenhan#readme )
ibus-hs : A simple incomplete ibus api ( https://github.com/Ongy/ibus-hs )
icalendar : iCalendar data types, parser, and printer ( https://github.com/chrra/iCalendar )
iconv : String encoding conversion ( https://hackage.haskell.org/package/iconv )
idiii : ID3v2 (tagging standard for MP3 files) library ( https://hackage.haskell.org/package/idiii )
idna : Implements IDNA (RFC 3490) ( https://hackage.haskell.org/package/idna )
ieee754 : Utilities for dealing with IEEE floating point numbers ( https://github.com/patperry/hs-ieee754 )
ifelse : Anaphoric and miscellaneous useful control-flow ( https://hackage.haskell.org/package/IfElse )
ignore : Handle ignore files of different VCSes ( https://github.com/agrafix/ignore )
ihaskell : A Haskell backend kernel for the IPython project ( https://github.com/gibiansky/IHaskell )
ihaskell-charts : IHaskell display instances for charts types ( http://www.github.com/gibiansky/ihaskell )
ihaskell-diagrams : IHaskell display instances for diagram types ( http://www.github.com/gibiansky/ihaskell )
ihaskell-hatex : IHaskell display instances for hatex ( http://www.github.com/gibiansky/IHaskell )
ilist : Optimised list functions for doing index-related things ( https://github.com/kowainik/ilist )
imagesize-conduit : Determine the size of some common image formats ( https://github.com/silkapp/imagesize-conduit )
imlib : Haskell binding for Imlib 2 ( https://hackage.haskell.org/package/Imlib )
implicit-hie : Auto generate hie-bios cradles and hie.yaml ( https://github.com/Avi-D-coder/implicit-hie#readme )
implicit-hie-cradle : Auto generate hie-bios cradles ( https://github.com/Avi-D-coder/implicit-hie-cradle#readme )
incipit-base : A Prelude for Polysemy – Base Reexports ( https://github.com/tek/incipit-core#readme )
incipit-core : A Prelude for Polysemy ( https://github.com/tek/incipit-core#readme )
indents : indentation sensitive parser-combinators for parsec ( https://github.com/jaspervdj/indents )
indexed : Haskell98 indexed functors, monads, comonads ( https://github.com/reinerp/indexed )
indexed-extras : Indexed functors, monads and comonads that require extensions to Haskell98 ( https://github.com/reinerp/indexed-extras )
indexed-list-literals : Type safe indexed list literals ( https://github.com/davidm-d/indexed-list-literals )
indexed-profunctors : Utilities for indexed profunctors ( https://hackage.haskell.org/package/indexed-profunctors )
indexed-traversable : FunctorWithIndex, FoldableWithIndex, TraversableWithIndex ( https://hackage.haskell.org/package/indexed-traversable )
indexed-traversable-instances : More instances of FunctorWithIndex, FoldableWithIndex, TraversableWithIndex ( https://hackage.haskell.org/package/indexed-traversable-instances )
infer-license : Infer software license from a given license file ( https://hackage.haskell.org/package/infer-license )
infinite-list : Infinite lists ( https://github.com/Bodigrim/infinite-list )
inflections : Inflections library for Haskell ( https://github.com/stackbuilders/inflections-hs )
influxdb : InfluxDB client library for Haskell ( https://github.com/maoe/influxdb-haskell )
ini : Quick and easy configuration files in the INI format ( https://github.com/chrisdone/ini )
inline-c : Write Haskell source files including C code inline. No FFI required ( https://hackage.haskell.org/package/inline-c )
inline-c-cpp : Lets you embed C++ code into Haskell ( https://hackage.haskell.org/package/inline-c-cpp )
insert-ordered-containers : Associative containers retaining insertion order for traversals ( https://github.com/phadej/insert-ordered-containers#readme )
inspection-testing : GHC plugin to do inspection testing ( https://github.com/nomeata/inspection-testing )
integer-conversion : Conversion from strings to Integer ( https://github.com/phadej/integer-conversion )
integer-logarithms : Integer logarithms ( https://github.com/haskellari/integer-logarithms )
integer-roots : Integer roots and perfect powers ( https://github.com/Bodigrim/integer-roots )
integration : Fast robust numeric integration via tanh-sinh quadrature ( https://github.com/ekmett/integration )
interlude : Replaces some Prelude functions for enhanced error reporting ( https://malde.org/~ketil/ )
intern : Efficient hash-consing for arbitrary data types ( https://github.com/ekmett/intern/ )
interpolate : String interpolation done right ( https://github.com/sol/interpolate#readme )
intervals : Interval Arithmetic ( https://github.com/ekmett/intervals )
invariant : Haskell98 invariant functors ( https://github.com/nfrisby/invariant-functors )
io-storage : A key-value store in the IO monad ( https://github.com/willdonnelly/io-storage )
io-streams : Simple, composable, and easy-to-use stream I/O ( https://hackage.haskell.org/package/io-streams )
io-streams-haproxy : HAProxy protocol 1.5 support for io-streams ( https://snapframework.com/ )
io-string-like : Classes to handle Prelude style IO functions for different datatypes ( https://github.com/clintonmead/io-string-like#readme )
iospec : A pure specification of the IO monad ( https://github.com/lambdabot/IOSpec )
iostring : A class of strings that can be involved in IO ( http://cs-syd.eu )
ipprint : Tiny helper for pretty-printing values in ghci console ( https://hackage.haskell.org/package/ipprint )
iproute : IP Routing Table ( https://www.mew.org/~kazu/proj/iproute/ )
ipv6addr : Library to deal with IPv6 address text representations ( https://github.com/MichelBoucey/IPv6Addr )
ipynb : Data structure for working with Jupyter notebooks (ipynb) ( https://hackage.haskell.org/package/ipynb )
ipython-kernel : A library for creating kernels for IPython frontends ( https://github.com/gibiansky/IHaskell )
irc : A small library for parsing IRC messages ( https://hackage.haskell.org/package/irc )
irc-core : IRC core library for glirc ( https://github.com/glguy/irc-core )
ireal : Real numbers and intervals with relatively efficient exact arithmetic ( https://hackage.haskell.org/package/ireal )
iso-deriving : Deriving via arbitrary isomorphisms ( https://hackage.haskell.org/package/iso-deriving )
iso3166-country-codes : A datatype for ISO 3166 country codes ( https://hackage.haskell.org/package/iso3166-country-codes )
iso8601-time : Convert to/from the ISO 8601 time format ( https://github.com/nh2/iso8601-time )
isocline : A portable alternative to GNU Readline ( https://github.com/daanx/isocline#readme )
isomorphism-class : Isomorphism typeclass solving the conversion problem ( https://github.com/nikita-volkov/isomorphism-class )
iwlib : Bindings for the iw C library ( https://github.com/jaor/iwlib )
ix-shapable : Reshape multi-dimensional arrays ( https://hackage.haskell.org/package/ix-shapable )
ixset : Efficient relational queries on Haskell sets ( https://happstack.com )
ixset-typed : Efficient relational queries on Haskell sets ( https://hackage.haskell.org/package/ixset-typed )
jail : Jailed IO monad ( https://hackage.haskell.org/package/jail )
jira-wiki-markup : Handle Jira wiki markup ( https://github.com/tarleb/jira-wiki-markup )
jmacro : QuasiQuotation library for programmatic generation of Javascript code ( https://hackage.haskell.org/package/jmacro )
jose-jwt : JSON Object Signing and Encryption Library ( https://github.com/tekul/jose-jwt )
js-chart : Obtain minified chart.js code ( https://github.com/jonascarpay/js-chart#readme )
js-dgtable : Obtain minified jquery.dgtable code ( https://github.com/ndmitchell/js-dgtable#readme )
js-flot : Obtain minified flot code ( https://github.com/ndmitchell/js-flot#readme )
js-jquery : Obtain minified jQuery code ( https://github.com/ndmitchell/js-jquery#readme )
jsaddle : Interface for JavaScript that works with GHCJS and GHC ( https://hackage.haskell.org/package/jsaddle )
jsaddle-warp : Interface for JavaScript that works with GHCJS and GHC ( https://hackage.haskell.org/package/jsaddle-warp )
json : Support for serialising Haskell to and from JSON ( https://hackage.haskell.org/package/json )
json-ast : Universal JSON AST datastructure ( https://github.com/nikita-volkov/json-ast )
json-bytes-builder : Direct-to-bytes JSON Builder ( https://github.com/nikita-volkov/json-bytes-builder )
json-types : Basic types for representing JSON ( https://hackage.haskell.org/package/json-types )
jsonb : JSON parser that uses byte strings ( https://github.com/solidsnack/JSONb/ )
judy : Fast, scalable, mutable dynamic arrays, maps and hashes ( https://github.com/mwotton/judy )
juicypixels : Picture loading/serialization (in png, jpeg, bitmap, gif, tga, tiff and radiance) ( https://github.com/Twinside/Juicy.Pixels )
juicypixels-blurhash : Blurhash is a very compact representation of a placeholder for an image ( https://github.com/SamProtas/JuicyPixels-blurhash#readme )
juicypixels-extra : Efficiently scale, crop, flip images with JuicyPixels ( https://github.com/mrkkrp/JuicyPixels-extra )
juicypixels-scale-dct : Scale JuicyPixels images with DCT ( https://github.com/phadej/JuicyPixels-scale-dct#readme )
jupyter : A library for creating and using Jupyter kernels ( https://github.com/gibiansky/haskell-jupyter )
jwt : JSON Web Token (JWT) decoding and encoding ( https://github.com/puffnfresh/haskell-jwt )
kan-extensions : Kan extensions, Kan lifts, the Yoneda lemma, and (co)density (co)monads ( https://github.com/ekmett/kan-extensions/ )
kansas-comet : A JavaScript push mechanism based on the comet idiom ( https://github.com/ku-fpg/kansas-comet/ )
keenser : Initial project template from stack ( https://github.com/jamesdabbs/keenser#readme )
keys : Keyed functors and containers ( https://github.com/ekmett/keys/ )
kinds : Emulation of subkinds and subkind polymorphism ( http://darcs.wolfgang.jeltsch.info/haskell/kinds )
lambdabot-core : Lambdabot core functionality ( https://wiki.haskell.org/Lambdabot )
lambdabot-haskell-plugins : Lambdabot Haskell plugins ( https://wiki.haskell.org/Lambdabot )
lambdabot-irc-plugins : IRC plugins for lambdabot ( https://wiki.haskell.org/Lambdabot )
lambdabot-misc-plugins : Lambdabot miscellaneous plugins ( https://wiki.haskell.org/Lambdabot )
lambdabot-novelty-plugins : Novelty plugins for Lambdabot ( https://wiki.haskell.org/Lambdabot )
lambdabot-reference-plugins : Lambdabot reference plugins ( https://wiki.haskell.org/Lambdabot )
lambdabot-social-plugins : Social plugins for Lambdabot ( https://wiki.haskell.org/Lambdabot )
lambdabot-trusted : Lambdabot trusted code ( https://wiki.haskell.org/Lambdabot )
language-bash : Parsing and pretty-printing Bash shell scripts ( https://github.com/knrafto/language-bash/ )
language-c : Analysis and generation of C code ( https://visq.github.io/language-c/ )
language-c-quote : C/CUDA/OpenCL/Objective-C quasiquoting library ( https://github.com/mainland/language-c-quote )
language-css : CSS 2.1 syntax ( https://github.com/tomjaguarpaw/language-css )
language-docker : Dockerfile parser, pretty-printer and embedded DSL ( https://github.com/hadolint/language-docker#readme )
language-dot : A library for the analysis and creation of Graphviz DOT files ( https://hackage.haskell.org/package/language-dot )
language-ecmascript : JavaScript parser and pretty-printer library ( https://github.com/jswebtools/language-ecmascript )
language-glsl : GLSL abstract syntax tree, parser, and pretty-printer ( https://hackage.haskell.org/package/language-glsl )
language-haskell-extract : Module to automatically extract functions from the local code ( https://github.com/finnsson/template-helper )
language-java : Manipulating Java source: abstract syntax, lexer, parser, and pretty-printer ( https://github.com/vincenthz/language-java )
language-javascript : Parser for JavaScript ( https://github.com/erikd/language-javascript )
language-lua : Lua parser and pretty-printer ( https://github.com/glguy/language-lua )
language-python : Parsing and pretty printing of Python code ( https://github.com/bjpop/language-python )
largeword : Provides a way of producing large WordN ( https://github.com/idontgetoutmuch/largeword )
latex : Parse, format and process LaTeX files ( https://www.haskell.org/haskellwiki/LaTeX )
lattices : Fine-grained library for constructing and manipulating lattices ( https://github.com/phadej/lattices/ )
lazy-csv : Efficient lazy parsers for CSV (comma-separated values) ( https://code.haskell.org/lazy-csv )
lazy-pbkdf2 : Lazy PBKDF2 generator ( https://hackage.haskell.org/package/Lazy-Pbkdf2 )
lazysmallcheck : A library for demand-driven testing of Haskell programs ( http://www.cs.york.ac.uk/~mfn/lazysmallcheck/ )
lcs : Find longest common sublist of two lists ( http://urchin.earth.li/~ian/cabal/lcs/ )
ldap : Haskell binding for C LDAP API ( https://github.com/ezyang/ldap-haskell )
leancheck : Enumerative property-based testing ( https://github.com/rudymatela/leancheck#readme )
lens-action : Monadic Getters and Folds ( https://github.com/ekmett/lens-action/ )
lens-aeson : Law-abiding lenses for aeson ( https://github.com/lens/lens-aeson/ )
lens-family : Lens Families ( https://hackage.haskell.org/package/lens-family )
lens-family-core : Haskell 2022 Lens Families ( https://hackage.haskell.org/package/lens-family-core )
lens-family-th : Generate lens-family style lenses ( https://github.com/DanBurton/lens-family-th#readme )
lens-filesystem : Lens interface for your filesystem; still a bit experimental ( https://github.com/ChrisPenner/lens-filesystem )
lenses : Simple Functional Lenses ( https://github.com/jvranish/Lenses/tree/master )
leveldb-haskell : Haskell bindings to LevelDB ( https://github.com/kim/leveldb-haskell )
lhs2tex : Preprocessor for typesetting Haskell sources with LaTeX ( https://github.com/kosmikus/lhs2tex )
libffi : A binding to libffi ( https://haskell.org/haskellwiki/Library/libffi )
liblastfm : Lastfm API interface ( https://hackage.haskell.org/package/liblastfm )
libmpd : An MPD client library ( https://github.com/vimus/libmpd-haskell#readme )
libnotify : Bindings to libnotify library ( https://hackage.haskell.org/package/libnotify )
libtagc : Binding to TagLib C library ( https://patch-tag.com/r/AndyStewart/libtagc/home )
libtelnet : Bindings to libtelnet ( https://git.sr.ht/~jack/libtelnet-haskell )
libvirt-hs : FFI bindings to libvirt virtualization API (http://libvirt.org) ( https://github.com/portnov/libvirt-hs )
libxml : Binding to libxml2 ( https://hackage.haskell.org/package/libxml )
libxml-sax : Bindings for the libXML2 SAX interface ( https://john-millikin.com/software/haskell-libxml/ )
libyaml : Low-level, streaming YAML interface ( https://github.com/snoyberg/yaml#readme )
libzip : Bindings to libzip, a library for manipulating zip archives ( http://bitbucket.org/astanin/hs-libzip/ )
lift-type : Lift a type from a Typeable constraint to a Template Haskell type ( https://github.com/parsonsmatt/lift-type#readme )
lifted-async : Run lifted IO operations asynchronously and wait for their results ( https://github.com/maoe/lifted-async )
lifted-base : lifted IO operations from the base library ( https://github.com/basvandijk/lifted-base )
linear-base : Standard library for linear types ( https://github.com/tweag/linear-base#README )
linear-generics : Generic programming library for generalised deriving ( https://github.com/linear-generics/linear-generics )
linux-file-extents : Retrieve file fragmentation information under Linux ( https://github.com/redneb/linux-file-extents )
linux-inotify : Thinner binding to the Linux Kernel's inotify interface ( https://hackage.haskell.org/package/linux-inotify )
linux-namespaces : Work with linux namespaces: create new or enter existing ones ( https://github.com/redneb/hs-linux-namespaces )
lio : Labeled IO Information Flow Control Library ( https://github.com/plsyssec/lio )
liquid-fixpoint : Predicate Abstraction-based Horn-Clause/Implication Constraint Solver ( https://github.com/ucsd-progsys/liquid-fixpoint#readme )
liquiddesugar : Haskell to GHC Core Desugarar for Liquid Haskell ( http://goto.ucsd.edu/liquidhaskell )
liquidhaskell : Liquid Types for Haskell ( https://github.com/ucsd-progsys/liquidhaskell )
list : List monad transformer and class ( https://github.com/yairchu/generator )
list-t : ListT done right ( https://github.com/nikita-volkov/list-t )
listlike : Generalized support for list-like structures ( https://github.com/ddssff/listlike )
listsafe : Safe wrappers for partial list functions, supporting MonadThrow ( https://github.com/ombocomp/listsafe )
listzipper : Simple zipper for lists ( https://hackage.haskell.org/package/ListZipper )
lmdb : Lightning MDB bindings ( https://github.com/dmbarbour/haskell-lmdb )
load-env : Load environment variables from a file ( https://github.com/pbrisbin/load-env#readme )
located-base : Location-aware variants of partial functions ( https://github.com/gridaphobe/located-base )
loch-th : Support for precise error locations in source files (Template Haskell version) ( https://github.com/liskin/loch-th )
lockfree-queue : Michael and Scott lock-free queues ( https://github.com/rrnewton/haskell-lockfree/wiki )
log-base : Structured logging solution (base package) ( https://github.com/scrive/log )
log-domain : Log-domain arithmetic ( https://github.com/ekmett/log-domain/ )
log-postgres : Structured logging solution (PostgreSQL back end) ( https://github.com/scrive/log )
logfloat : Log-domain floating point numbers ( https://code.haskell.org/~wren/ )
logging-effect : A mtl-style monad transformer for general purpose and compositional logging ( https://github.com/ocharles/logging-effect )
logging-facade : Simple logging abstraction that allows multiple back-ends ( https://github.com/sol/logging-facade#readme )
logict : A backtracking logic-programming monad ( https://github.com/Bodigrim/logict#readme )
logict-state : Library for logic programming based on haskell package logict ( https://github.com/atzedijkstra/logict-state )
loop : Fast loops (for when GHC can't optimize forM_) ( https://github.com/nh2/loop )
lrucache : a simple, pure LRU cache ( https://github.com/chowells79/lrucache )
lsp : Haskell library for the Microsoft Language Server Protocol ( https://github.com/haskell/lsp )
lsp-test : Functional test framework for LSP servers ( https://github.com/haskell/lsp/blob/master/lsp-test/README.md )
lsp-types : Haskell library for the Microsoft Language Server Protocol, data types ( https://github.com/haskell/lsp )
lua-arbitrary : Arbitrary instances for Lua types ( https://hslua.org/ )
lua-bc : Lua bytecode parser ( https://github.com/GaloisInc/lua-bc )
lucid : Clear to write, read and edit DSL for HTML ( https://github.com/chrisdone/lucid )
lucid-svg : DSL for SVG using lucid for HTML ( https://github.com/jeffreyrosenbluth/lucid-svg.git )
lukko : File locking ( https://hackage.haskell.org/package/lukko )
lushtags : Create ctags compatible tags files for Haskell programs ( https://github.com/bitc/lushtags )
lz4 : LZ4 compression for ByteStrings ( https://github.com/mwotton/lz4hs )
lzma : LZMA/XZ compression and decompression ( https://github.com/hvr/lzma )
maccatcher : Obtain the host MAC address on *NIX and Windows ( https://hackage.haskell.org/package/maccatcher )
machines : Networked stream transducers ( https://github.com/ekmett/machines/ )
mackerel-client : An API client library for Mackerel ( https://github.com/itchyny/mackerel-client-hs )
magic : Interface to C file/magic library ( https://hackage.haskell.org/package/magic )
mainland-pretty : Pretty printing designed for printing source code ( https://github.com/mainland/mainland-pretty )
managed : A monad for managed values ( https://hackage.haskell.org/package/managed )
map-syntax : Syntax sugar for defining maps ( https://hackage.haskell.org/package/map-syntax )
markdown : Convert Markdown to HTML, with XSS protection ( https://github.com/snoyberg/markdown )
markdown-unlit : Literate Haskell support for Markdown ( https://github.com/sol/markdown-unlit#readme )
markov-chain : Markov Chains for generating random sequences with a user definable behaviour ( http://code.haskell.org/~thielema/markov-chain/ )
massiv : Massiv (Массив) is an Array Library ( https://github.com/lehins/massiv )
massiv-io : Import/export of Image files into massiv Arrays ( https://github.com/lehins/massiv-io )
massiv-test : Library that contains generators, properties and tests for Massiv Array Library ( https://github.com/lehins/massiv )
math-functions : Collection of tools for numeric computations ( https://github.com/haskell/math-functions )
matrices : native matrix based on vector ( https://hackage.haskell.org/package/matrices )
matrix : A native implementation of matrix operations ( https://hackage.haskell.org/package/matrix )
mecab : A Haskell binding to MeCab ( https://github.com/tanakh/hsmecab )
mediawiki : Interfacing with the MediaWiki API ( https://hackage.haskell.org/package/mediawiki )
megaparsec : Monadic parser combinators ( https://github.com/mrkkrp/megaparsec )
megaparsec-tests : Test utilities and the test suite of Megaparsec ( https://github.com/mrkkrp/megaparsec )
meldable-heap : Asymptotically optimal, Coq-verified meldable heaps, AKA priority queues ( https://github.com/jbapple/priority-queues )
membership : Indices for type level lists ( https://github.com/fumieval/membership )
memoize : A memoization library ( https://hackage.haskell.org/package/memoize )
memory : memory and related abstraction stuff ( https://github.com/vincenthz/hs-memory )
memotrie : Trie-based memo functions ( https://github.com/conal/MemoTrie )
mersenne-random : Generate high quality pseudorandom numbers using a SIMD Fast Mersenne Twister ( https://code.haskell.org/~dons/code/mersenne-random )
mersenne-random-pure64 : Generate high quality pseudorandom numbers purely using a Mersenne Twister ( http://code.haskell.org/~dons/code/mersenne-random-pure64/ )
messagepack : Serialize instance for Message Pack Object ( https://github.com/rodrigosetti/messagepack )
mfsolve : Equation solver and calculator a la metafont ( https://hackage.haskell.org/package/mfsolve )
microaeson : A tiny JSON library with light dependency footprint ( https://hackage.haskell.org/package/microaeson )
microlens : A tiny lens library with no dependencies ( https://github.com/stevenfontanella/microlens )
microlens-aeson : Law-abiding lenses for Aeson, using microlens ( https://github.com/fosskers/microlens-aeson/ )
microlens-ghc : microlens + array, bytestring, containers, transformers ( https://github.com/stevenfontanella/microlens )
microlens-mtl : microlens support for Reader/Writer/State from mtl ( https://github.com/monadfix/microlens )
microlens-platform : microlens + all batteries included (best for apps) ( https://github.com/stevenfontanella/microlens )
microlens-th : Automatic generation of record lenses for microlens ( https://github.com/stevenfontanella/microlens )
microspec : Tiny QuickCheck test library with minimal dependencies ( https://hackage.haskell.org/package/microspec )
microstache : Mustache templates for Haskell ( https://github.com/haskellari/microstache )
microtimer : A tiny library for benchmarking IO actions ( https://thoughtpolice.github.com/hs-microtimer )
midi : Handling of MIDI messages and files ( https://wiki.haskell.org/MIDI )
midi-alsa : Convert between datatypes of the midi and the alsa packages ( https://www.haskell.org/haskellwiki/MIDI )
migrant-core : Semi-automatic database schema migrations ( https://github.com/tdammers/migrant )
migrant-sqlite-simple : Semi-automatic database schema migrations ( https://github.com/tdammers/migrant )
mime-mail : Compose MIME email messages ( https://github.com/snoyberg/mime-mail )
mime-types : Basic mime-type handling types and functions ( https://github.com/yesodweb/wai )
minisat : A Haskell bundle of the Minisat SAT solver ( https://hackage.haskell.org/package/minisat )
mintty : A reliable way to detect the presence of a MinTTY console on Windows ( https://github.com/RyanGlScott/mintty )
misfortune : fortune-mod clone ( https://github.com/ncfavier/misfortune )
miso : A tasty Haskell front-end framework ( https://github.com/dmjio/miso )
missing-foreign : Convenience functions for FFI work ( https://hackage.haskell.org/package/missing-foreign )
missingh : Large utility library ( https://hackage.haskell.org/package/MissingH )
mmap : Memory mapped files for POSIX and Windows ( https://hackage.haskell.org/package/mmap )
mmark : Strict markdown processor for writers ( https://github.com/mmark-md/mmark )
mmorph : Monad morphisms ( https://hackage.haskell.org/package/mmorph )
mockery : Support functions for automated testing ( https://hackage.haskell.org/package/mockery )
mod : Fast type-safe modular arithmetic ( https://github.com/Bodigrim/mod )
modern-uri : Modern library for working with URIs ( https://github.com/mrkkrp/modern-uri )
modular-arithmetic : A type for integers modulo some constant ( https://github.com/TikhonJelvis/modular-arithmetic )
monad-control : Lift control operations, like exception catching, through monad transformers ( https://github.com/basvandijk/monad-control )
monad-control-aligned : Just like monad-control, except less efficient, and the monadic state terms are all * - * ( https://github.com/athanclark/monad-control#readme )
monad-dijkstra : A monad transformer for weighted graph searches ( https://github.com/ennocramer/monad-dijkstra )
monad-extras : Extra utility functions for working with monads ( https://github.com/jwiegley/monad-extras )
monad-journal : Pure logger typeclass and monad transformer ( https://github.com/phaazon/monad-journal )
monad-logger : A class of monads which can log messages ( https://github.com/snoyberg/monad-logger#readme )
monad-logger-syslog : syslog output for monad-logger ( https://github.com/fpco/monad-logger-syslog )
monad-loops : Monadic loops ( https://github.com/mokus0/monad-loops )
monad-memo : Memoization monad transformer ( https://github.com/EduardSergeev/monad-memo )
monad-par : A library for parallel programming based on a monad ( https://github.com/simonmar/monad-par )
monad-par-extras : Combinators and extra features for Par monads ( https://github.com/simonmar/monad-par )
monad-parallel : Parallel execution of monadic computations ( https://hub.darcs.net/blamario/SCC.wiki/ )
monad-peel : Lift control operations like exception catching through monad transformers ( https://andersk.mit.edu/haskell/monad-peel/ )
monad-products : Monad products ( https://github.com/ekmett/monad-products )
monad-skeleton : Monads of program skeleta ( https://github.com/fumieval/monad-skeleton )
monad-time : Type class for monads which carry the notion of the current time ( https://github.com/scrive/monad-time )
monad-unify : Generic first-order unification ( https://hackage.haskell.org/package/monad-unify )
monad-unlift : Typeclasses for representing monad transformer unlifting ( https://github.com/fpco/monad-unlift )
monadcatchio-mtl : Monad-transformer version of the Control.Exception module ( http://darcsden.com/jcpetruzza/MonadCatchIO-mtl )
monadcatchio-transformers : Monad-transformer compatible version of the Control.Exception module ( https://hackage.haskell.org/package/MonadCatchIO-transformers )
monadcryptorandom : A monad for using CryptoRandomGen ( https://github.com/TomMD/monadcryptorandom )
monadio : Overloading of concurrency variables ( https://hackage.haskell.org/package/monadIO )
monadlib : A collection of monad transformers ( https://wiki.github.com/yav/monadlib )
monadlist : Monadic versions of list functions ( https://hackage.haskell.org/package/monadlist )
monadloc : A class for monads which can keep a monadic call trace ( https://github.com/pepeiborra/monadloc )
monadplus : Haskell98 partial maps and filters over MonadPlus ( https://hackage.haskell.org/package/monadplus )
monadprompt : MonadPrompt, implementation and examples ( https://hackage.haskell.org/package/MonadPrompt )
monadrandom : Random-number generation monad ( https://hackage.haskell.org/package/MonadRandom )
monads-tf : Monad classes, using type families ( https://github.com/typeclasses/monads-tf )
mongodb : Driver (client) for MongoDB, a free, scalable, fast, document DBMS ( https://github.com/mongodb-haskell/mongodb )
monky : A system state collecting library and application ( https://hackage.haskell.org/package/monky )
mono-traversable : Type classes for mapping, folding, and traversing monomorphic containers ( https://github.com/snoyberg/mono-traversable#readme )
mono-traversable-instances : Extra typeclass instances for mono-traversable ( https://github.com/snoyberg/mono-traversable#readme )
monoid-extras : Various extra monoid-related definitions and utilities ( https://hackage.haskell.org/package/monoid-extras )
monoid-subclasses : Subclasses of Monoid ( https://github.com/blamario/monoid-subclasses/ )
monoid-transformer : Monoid counterparts to some ubiquitous monad transformers ( https://hackage.haskell.org/package/monoid-transformer )
monoidal-containers : Containers with monoidal accumulation ( https://github.com/bgamari/monoidal-containers )
monomer : A GUI library for writing native Haskell applications ( HOMEPAGE=" )
morsecode : Morse code ( https://hackage.haskell.org/package/MorseCode )
mountpoints : list mount points ( https://hackage.haskell.org/package/mountpoints )
msgpack : A Haskell implementation of MessagePack ( https://msgpack.org/ )
mtl : Monad classes, using functional dependencies ( https://github.com/haskell/mtl )
mtl-compat : Backported Control.Monad.Except module from mtl ( https://github.com/haskell-compat/mtl-compat )
mtl-prelude : Reexports of most definitions from \"mtl\" and \"transformers\" ( https://github.com/nikita-volkov/mtl-prelude )
mtlparse : parse library using mtl package ( http://homepage3.nifty.com/salamander/second/projects/mtlparse/ )
mueval : Safely evaluate pure Haskell expressions ( https://github.com/gwern/mueval )
multimap : A multimap ( https://hub.darcs.net/scravy/multimap )
multipart : Parsers for the HTTP multipart format ( http://www.github.com/silkapp/multipart )
multiset : The Data.MultiSet container type ( https://hackage.haskell.org/package/multiset )
multiset-comb : Combinatorial algorithms over multisets ( https://hackage.haskell.org/package/multiset-comb )
multistate : like mtl's ReaderT / WriterT / StateT, but more than one contained value/type ( https://github.com/lspitzner/multistate )
murmur-hash : MurmurHash2 implementation for Haskell ( https://github.com/nominolo/murmur-hash )
mustache : A mustache template parser library ( https://github.com/JustusAdam/mustache )
mutable-containers : Abstractions and concrete implementations of mutable containers ( https://github.com/snoyberg/mono-traversable#readme )
mwc-probability : Sampling function-based probability distributions ( https://github.com/jtobin/mwc-probability )
mwc-random : Fast, high quality pseudo random number generation ( https://github.com/bos/mwc-random )
mysql : A low-level MySQL client library ( https://github.com/paul-rouse/mysql )
mysql-simple : A mid-level MySQL client library ( https://github.com/paul-rouse/mysql-simple )
named : Named parameters (keyword arguments) for Haskell ( https://github.com/monadfix/named )
namegenerator : A name generator written in Haskell ( https://github.com/pommicket/name-generator-haskell )
names-th : Manipulate name strings for TH ( http://khibino.github.io/haskell-relational-record/ )
nano-md5 : Efficient, ByteString bindings to OpenSSL ( http://code.haskell.org/~dons/code/nano-md5 )
nanomsg : nanomsg - scalability protocols library ( https://hackage.haskell.org/package/nanomsg )
nanomsg-haskell : Bindings to the nanomsg library ( https://github.com/ivarnymoen/nanomsg-haskell )
nanoprolog : Very small interpreter for a Prolog-like language ( https://hackage.haskell.org/package/NanoProlog )
nanospec : A lightweight implementation of a subset of Hspec's API ( https://github.com/hspec/nanospec#readme )
nanovg : Haskell bindings for nanovg ( https://github.com/cocreature/nanovg-hs )
natural-arithmetic : Arithmetic of natural numbers ( https://github.com/andrewthad/natural-arithmetic )
natural-numbers : Natural numbers ( http://darcs.wolfgang.jeltsch.info/haskell/natural-numbers )
natural-sort : User-friendly text collation ( https://john-millikin.com/software/natural-sort/ )
natural-transformation : A natural transformation package ( https://github.com/ku-fpg/natural-transformation )
ncurses : Modernised bindings to GNU ncurses ( https://john-millikin.com/software/haskell-ncurses/ )
neat-interpolation : A quasiquoter for neat and simple multiline text interpolation ( https://github.com/nikita-volkov/neat-interpolation )
netlink : Netlink communication for Haskell ( https://github.com/Ongy/netlink-hs )
netpbm : Loading PBM, PGM, PPM image files ( https://github.com/nh2/haskell-netpbm )
netwire : Functional reactive programming library ( https://github.com/esoeylemez/netwire )
network : Low-level networking interface ( https://github.com/haskell/network )
network-bsd : POSIX network database (netdb.h) API ( https://github.com/haskell/network-bsd )
network-byte-order : Network byte order utilities ( https://hackage.haskell.org/package/network-byte-order )
network-conduit : Stream socket data using conduits. (deprecated) ( https://github.com/snoyberg/conduit )
network-data : Library for network data structures and their serialization ( https://hackage.haskell.org/package/network-data )
network-enumerator : Enumerators for network sockets ( https://john-millikin.com/software/network-enumerator/ )
network-fancy : Networking support with a cleaner API ( https://github.com/taruti/network-fancy )
network-info : Access the local computer's basic network configuration ( https://github.com/jacobstanley/network-info )
network-ip : Internet Protocol data structures ( https://github.com/mvv/network-ip )
network-msg : Recvmsg and sendmsg bindings ( https://hackage.haskell.org/package/network-msg )
network-multicast : Simple multicast library ( https://hackage.haskell.org/package/network-multicast )
network-run : Simple network runner library ( https://hackage.haskell.org/package/network-run )
network-simple : Simple network sockets usage patterns ( https://github.com/k0001/network-simple )
network-transport : Network abstraction layer ( https://haskell-distributed.github.com )
network-transport-tcp : TCP instantiation of Network.Transport ( http://haskell-distributed.github.com )
network-transport-tests : Unit tests for Network.Transport implementations ( http://haskell-distributed.github.com )
network-uri : URI manipulation ( https://github.com/haskell/network-uri )
newtype : A typeclass and set of functions for working with newtypes ( https://hackage.haskell.org/package/newtype )
newtype-generics : A typeclass and set of functions for working with newtypes ( https://github.com/sjakobi/newtype-generics )
ngx-export : Helper module for Nginx haskell module ( https://github.com/lyokha/nginx-haskell-module )
nicify : Pretty print the standard output of default 'Show' instances ( https://hackage.haskell.org/package/nicify )
nicify-lib : Pretty print the standard output of default 'Show' instances ( https://hackage.haskell.org/package/nicify-lib )
nix-derivation : Parse and render *.drv files ( https://hackage.haskell.org/package/nix-derivation )
non-empty : List-like structures with static restrictions on the number of elements ( http://hub.darcs.net/thielema/non-empty/ )
non-negative : Non-negative numbers ( http://code.haskell.org/~thielema/non-negative/ )
nonce : Generate cryptographic nonces ( https://github.com/prowdsponsor/nonce )
nonempty-containers : Non-empty variants of containers data types, with full API ( https://github.com/mstksg/nonempty-containers#readme )
nonempty-vector : Non-empty vectors ( https://github.com/emilypi/nonempty-vector )
normaldistribution : Minimum fuss normally distributed random values ( https://github.com/bjornbm/normaldistribution )
nothunks : Examine values for unexpected thunks ( https://hackage.haskell.org/package/nothunks )
numbers : Various number types ( https://github.com/jwiegley/numbers#readme )
numbersieves : Number Theoretic Sieves: primes, factorization, and Euler's Totient ( http://patch-tag.com/r/lpsmith/NumberSieves )
numeric-extras : Useful tools from the C standard library ( https://github.com/ekmett/numeric-extras )
numeric-prelude : An experimental alternative hierarchy of numeric type classes ( https://www.haskell.org/haskellwiki/Numeric_Prelude )
numeric-quest : Math and quantum mechanics ( https://www.haskell.org/haskellwiki/Numeric_Quest )
numinstances : Instances of numeric classes for functions and tuples ( https://github.com/conal/NumInstances )
numtype : Type-level (low cardinality) integers ( http://dimensional.googlecode.com/ )
numtype-dk : Type-level integers, using TypeNats, Data Kinds, and Closed Type Families ( https://github.com/bjornbm/numtype-dk )
objectname : Explicitly handled object names ( https://github.com/svenpanne/ObjectName )
oeis : Interface to the Online Encyclopedia of Integer Sequences (OEIS) ( https://hackage.haskell.org/package/oeis )
old-locale : locale library ( https://hackage.haskell.org/package/old-locale )
old-time : Time library ( https://hackage.haskell.org/package/old-time )
one-liner : Constraint-based generics ( https://github.com/sjoerdvisscher/one-liner )
onetuple : Singleton Tuple ( https://hackage.haskell.org/package/OneTuple )
only : The 1-tuple type or single-value \"collection\" ( https://hackage.haskell.org/package/Only )
oo-prototypes : Support for OO-like prototypes ( https://github.com/yi-editor/oo-prototypes )
opaleye : An SQL-generating DSL targeting PostgreSQL ( https://github.com/tomjaguarpaw/haskell-opaleye )
open-browser : Open a web browser from Haskell ( https://github.com/rightfold/open-browser )
openal : A binding to the OpenAL cross-platform 3D audio API ( https://github.com/haskell-openal/ALUT )
openclwrappers : The OpenCL Standard for heterogeneous data-parallel computing ( https://github.com/jkarlson/OpenCLWrappers )
opengl : A binding for the OpenGL graphics system ( https://wiki.haskell.org/OpenGL )
openglraw : A raw binding for the OpenGL graphics system ( https://www.haskell.org/haskellwiki/Opengl )
openssl-streams : OpenSSL network support for io-streams ( https://hackage.haskell.org/package/openssl-streams )
opentelemetry : The OpenTelemetry Haskell Client https://opentelemetry.io ( https://hackage.haskell.org/package/opentelemetry )
operational : Implementation of difficult monads made easy with operational semantics ( https://wiki.haskell.org/Operational )
optics : Optics as an abstract interface ( https://hackage.haskell.org/package/optics )
optics-core : Optics as an abstract interface: core definitions ( https://hackage.haskell.org/package/optics-core )
optics-extra : Extra utilities and instances for optics-core ( https://hackage.haskell.org/package/optics-extra )
optics-th : Optics construction using TemplateHaskell ( https://hackage.haskell.org/package/optics-th )
optional-args : Optional function arguments ( https://hackage.haskell.org/package/optional-args )
options : Powerful and easy command-line option parser ( https://github.com/typeclasses/options/ )
optparse-applicative : Utilities and combinators for parsing command line options ( https://github.com/pcapriotti/optparse-applicative )
optparse-declarative : Declarative command line option parser ( https://github.com/tanakh/optparse-declarative )
optparse-generic : Auto-generate a command-line parser for your datatype ( https://hackage.haskell.org/package/optparse-generic )
optparse-simple : Simple interface to optparse-applicative ( https://github.com/fpco/optparse-simple#readme )
ordered-containers : Set- and Map-like types that remember the order elements were inserted ( https://hackage.haskell.org/package/ordered-containers )
ormolu : A formatter for Haskell source code ( https://github.com/tweag/ormolu )
pager : Open up a pager, like 'less' or 'more' ( https://github.com/pharpend/pager )
palette : Utilities for choosing and creating color schemes ( http://projects.haskell.org/diagrams )
pandoc-crossref : Pandoc filter for cross-references ( https://github.com/lierdakil/pandoc-crossref#readme )
pandoc-lua-engine : Lua engine to power custom pandoc conversions ( https://pandoc.org )
pandoc-lua-marshal : Use pandoc types in Lua ( https://github.com/pandoc/pandoc-lua-marshal )
pandoc-server : Pandoc document conversion as an HTTP servant-server ( https://pandoc.org )
pandoc-stylefrommeta : Pandoc filter to customize links, images and paragraphs ( https://github.com/lyokha/styleFromMeta )
pandoc-types : Types for representing a structured document ( https://pandoc.org/ )
pango : Binding to the Pango text rendering engine ( https://projects.haskell.org/gtk2hs/ )
panic : A convenient way to panic ( https://hackage.haskell.org/package/panic )
pantry : Content addressable Haskell package management ( https://github.com/commercialhaskell/pantry#readme )
parallel : Parallel programming library ( https://hackage.haskell.org/package/parallel )
parallel-io : Combinators for executing IO actions in parallel on a thread pool ( https://batterseapower.github.com/parallel-io )
parseargs : Full-featured command-line argument parsing library ( https://github.com/BartMassey/parseargs )
parsec : Monadic parser combinators ( https://github.com/haskell/parsec )
parsec-extra : Some miscellaneous basic string parsers ( https://hackage.haskell.org/package/parsec-extra )
parsec-numbers : Utilities for parsing numbers from strings ( https://hackage.haskell.org/package/parsec-numbers )
parsec-permutation : Applicative permutation parser for Parsec (replacement for Text.Parsec.Perm) ( https://hackage.haskell.org/package/parsec-permutation )
parsec1 : Portable monadic parser combinators ( https://hackage.haskell.org/package/parsec1 )
parsec3-numbers : Utilities for parsing numbers from Char sequences ( https://hackage.haskell.org/package/parsec3-numbers )
parsedate : Data and time parsing for CalendarTime ( http://www.cs.chalmers.se/~bringert/darcs/parsedate/doc/ )
parser-combinators : Lightweight package providing commonly useful parser combinators ( https://github.com/mrkkrp/parser-combinators )
parsers : Parsing combinators ( https://github.com/ekmett/parsers/ )
password : Hashing and checking of passwords ( https://github.com/cdepillabout/password/tree/master/password#readme )
password-types : Types for handling passwords ( https://github.com/cdepillabout/password/tree/master/password-types#readme )
patch : Data structures for describing changes to other data structures ( https://obsidian.systems )
path : Support for well-typed paths ( https://hackage.haskell.org/package/path )
path-extra : URLs without host information ( https://github.com/athanclark/path-extra#readme )
path-io : Interface to ‘directory’ package for users of ‘path’ ( https://github.com/mrkkrp/path-io )
path-pieces : Components of paths ( https://hackage.haskell.org/package/path-pieces )
paths : Library for representing and manipulating type-safe file paths ( https://hackage.haskell.org/package/paths )
pathtype : Type-safe replacement for System.FilePath etc ( http://hub.darcs.net/thielema/pathtype/ )
patience : Patience diff and longest increasing subsequence ( https://github.com/chessai/patience )
pattern-arrows : Arrows for Pretty Printing ( https://blog.functorial.com/posts/2013-10-27-Pretty-Printing-Arrows.html )
pcap : A system-independent interface for user-level packet capture ( https://github.com/bos/pcap )
pcg-random : Haskell bindings to the PCG random number generator ( https://github.com/cchalmers/pcg-random )
pcre-heavy : A regexp library on top of pcre-light you can actually use ( https://github.com/myfreeweb/pcre-heavy )
pcre-light : Portable regex library for Perl 5 compatible regular expressions ( https://github.com/Daniel-Diaz/pcre-light )
pdfinfo : Wrapper around the pdfinfo command ( https://github.com/chrisdone/pdfinfo )
pem : Privacy Enhanced Mail (PEM) format reader and writer ( https://github.com/vincenthz/hs-pem )
persistable-record : Binding between SQL database values and haskell records ( http://khibino.github.io/haskell-relational-record/ )
persistable-types-hdbc-pg : HDBC and Relational-Record instances of PostgreSQL extended types ( http://khibino.github.io/haskell-relational-record/ )
persistent : Type-safe, multi-backend data serialization ( https://www.yesodweb.com/book/persistent )
persistent-instances-iproute : Persistent instances for types in iproute ( https://hackage.haskell.org/package/persistent-instances-iproute )
persistent-mongodb : Backend for the persistent library using mongoDB ( https://www.yesodweb.com/book/persistent )
persistent-mysql : Backend for the persistent library using MySQL database server ( https://www.yesodweb.com/book/persistent )
persistent-odbc : Backend for the persistent library using ODBC ( https://github.com/gbwey/persistent-odbc )
persistent-postgresql : Backend for the persistent library using postgresql ( https://www.yesodweb.com/book/persistent )
persistent-qq : Provides a quasi-quoter for raw SQL for persistent ( https://github.com/yesodweb/persistent#readme )
persistent-redis : Backend for persistent library using Redis ( https://hackage.haskell.org/package/persistent-redis )
persistent-relational-record : relational-record on persistent backends ( https://github.com/himura/persistent-relational-record )
persistent-sqlite : Backend for the persistent library using sqlite3 ( https://www.yesodweb.com/book/persistent )
persistent-template : Type-safe, non-relational, multi-backend persistence ( https://www.yesodweb.com/book/persistent )
persistent-test : Tests for Persistent ( https://www.yesodweb.com/book/persistent )
pgm : Pure Haskell implementation of PGM image format ( https://github.com/astanin/haskell-pgm )
pgp-wordlist : Translate between binary data and a human-readable collection of words ( https://github.com/quchen/pgp-wordlist )
picedit : simple image manipulation functions ( https://github.com/mdibaiee/picedit#readme )
pid1 : Do signal handling and orphan reaping for Unix PID1 init processes ( https://github.com/fpco/pid1#readme )
pipes : Compositional pipelines ( https://hackage.haskell.org/package/pipes )
pipes-attoparsec : Attoparsec and Pipes integration ( https://github.com/k0001/pipes-attoparsec )
pipes-binary : Encode and decode binary streams using the pipes and binary libraries ( https://github.com/k0001/pipes-binary )
pipes-bytestring : ByteString support for pipes ( https://hackage.haskell.org/package/pipes-bytestring )
pipes-cereal : Encode and decode binary streams using the pipes and cereal libraries ( https://hackage.haskell.org/package/pipes-cereal )
pipes-concurrency : Concurrency for the pipes ecosystem ( https://hackage.haskell.org/package/pipes-concurrency )
pipes-group : Group streams into substreams ( https://hackage.haskell.org/package/pipes-group )
pipes-http : HTTP client with pipes interface ( https://hackage.haskell.org/package/pipes-http )
pipes-network : Use network sockets together with the pipes library ( https://github.com/k0001/pipes-network )
pipes-parse : Parsing infrastructure for the pipes ecosystem ( https://hackage.haskell.org/package/pipes-parse )
pipes-random : Producers for handling randomness ( https://github.com/fosskers/pipes-random )
pipes-safe : Safety for the pipes ecosystem ( https://hackage.haskell.org/package/pipes-safe )
pipes-text : properly streaming text ( https://github.com/pjones/pipes-text )
pipes-zlib : Zlib and GZip compression and decompression for Pipes streams ( https://github.com/k0001/pipes-zlib )
placeholders : Placeholders for use while developing Haskell code ( https://github.com/ahammar/placeholders )
plailude : plaimi's prelude ( https://secure.plaimi.net/works/plailude )
ploterific : Basic plotting of tabular data for the command line ( https://github.com/GregorySchwartz/ploterific#readme )
plugins : Dynamic linking for Haskell and C objects ( https://github.com/stepcut/plugins )
plugins-auto : Automatic recompilation and reloading of haskell modules ( https://hackage.haskell.org/package/plugins-auto )
pointed : Pointed and copointed data ( https://github.com/ekmett/pointed/ )
pointedlist : A zipper-like comonad which works as a list, tracking a position ( https://hackage.haskell.org/package/pointedlist )
pointfree : Tool for refactoring expressions into pointfree form ( https://hackage.haskell.org/package/pointfree )
pointful : Pointful refactoring tool ( https://github.com/23Skidoo/pointful )
polynomial : Polynomials ( https://github.com/mokus0/polynomial )
polyparse : A variety of alternative parser combinator libraries ( https://code.haskell.org/~malcolm/polyparse/ )
polysemy : Higher-order, low-boilerplate free monads ( https://github.com/polysemy-research/polysemy#readme )
polysemy-plugin : Disambiguate obvious uses of effects ( https://github.com/polysemy-research/polysemy#readme )
polysemy-test : Polysemy Effects for Testing ( https://github.com/tek/polysemy-test#readme )
polysemy-time : Polysemy effects for time ( https://github.com/tek/polysemy-time#readme )
polysemy-zoo : Experimental, user-contributed effects and interpreters for polysemy ( https://github.com/polysemy-research/polysemy-zoo#readme )
port-utils : Utilities for creating and waiting on ports ( https://github.com/jfischoff/port-utils#readme )
portaudio : Haskell bindings for the PortAudio library ( https://code.haskell.org/portaudio )
portmidi : A binding for PortMedia/PortMidi ( https://github.com/ninegua/PortMidi )
posix-escape : Quote arguments to be passed through the Unix shell ( https://hackage.haskell.org/package/posix-escape )
postgres-options : An Options type representing options for postgres connections ( https://github.com/jfischoff/postgres-options#readme )
postgresql-binary : Encoders and decoders for the PostgreSQL's binary format ( https://github.com/nikita-volkov/postgresql-binary )
postgresql-libpq : low-level binding to libpq ( https://github.com/haskellari/postgresql-libpq )
postgresql-simple : Mid-Level PostgreSQL client library ( https://hackage.haskell.org/package/postgresql-simple )
postgresql-simple-migration : PostgreSQL Schema Migrations ( https://github.com/ameingast/postgresql-simple-migration )
postgresql-syntax : PostgreSQL AST parsing and rendering ( https://github.com/nikita-volkov/postgresql-syntax )
postgresql-typed : PostgreSQL interface with compile-time SQL type checking, optional HDBC backend ( https://github.com/dylex/postgresql-typed )
pqueue : Reliable, persistent, fast priority queues ( https://github.com/lspitzner/pqueue )
prelude-compat : Provide Prelude and Data.List with fixed content across GHC versions ( https://hackage.haskell.org/package/prelude-compat )
prelude-extras : Higher order versions of Prelude classes ( https://github.com/ekmett/prelude-extras )
preprocessor-tools : A framework for extending Haskell's syntax via quick-and-dirty preprocessors ( https://github.com/tov/preprocessor-tools-hs )
presburger : A decision procedure for quantifier-free linear arithmetic ( https://github.com/yav/presburger )
pretty-hex : A library for hex dumps of ByteStrings ( https://hackage.haskell.org/package/pretty-hex )
pretty-ncols : A implementation of multi-column layout w/ Text.PrettyPrint ( https://hackage.haskell.org/package/pretty-ncols )
pretty-show : Tools for working with derived 'Show' instances and generic inspection of values ( https://wiki.github.com/yav/pretty-show )
pretty-simple : pretty printer for data types with a 'Show' instance ( https://github.com/cdepillabout/pretty-simple )
pretty-terminal : Styling and coloring terminal output with ANSI escape sequences ( https://github.com/loganmac/pretty-terminal#readme )
pretty-tree : Pretty-print trees ( https://hackage.haskell.org/package/pretty-tree )
prettyclass : Pretty printing class similar to Show ( https://hackage.haskell.org/package/prettyclass )
prettyprinter : A modern, easy to use, well-documented, extensible pretty-printer ( https://github.com/quchen/prettyprinter )
prettyprinter-ansi-terminal : ANSI terminal backend for the »prettyprinter« package ( https://github.com/quchen/prettyprinter )
prettyprinter-compat-ansi-wl-pprint : Drop-in compatibility package from ansi-wl-pprint to prettyprinter ( https://github.com/quchen/prettyprinter )
prettyprinter-interp : Efficient interpolation for Prettyprinter ( https://github.com/DigitalBrains1/prettyprinter-interp )
prim-uniq : Opaque unique identifiers in primitive state monads ( https://github.com/obsidiansystems/prim-uniq )
primes : Efficient, purely functional generation of prime numbers ( https://github.com/sebfisch/primes )
primitive : Primitive memory-related operations ( https://github.com/haskell/primitive )
primitive-addr : Addresses to unmanaged memory ( https://github.com/andrewthad/primitive-addr )
primitive-checked : primitive functions with bounds-checking ( https://github.com/haskell-primitive/primitive-checked#readme )
primitive-extras : Extras for the \"primitive\" library ( https://github.com/metrix-ai/primitive-extras )
primitive-offset : Types for offsets into unboxed arrays ( https://github.com/andrewthad/primitive-offset )
primitive-unaligned : Unaligned access to primitive arrays ( https://github.com/haskell-primitive/primitive-unaligned )
primitive-unlifted : Primitive GHC types with unlifted types inside ( https://github.com/haskell-primitive/primitive-unlifted )
probability : Probabilistic Functional Programming ( https://www.haskell.org/haskellwiki/Probabilistic_Functional_Programming )
proc : Parse process information for Linux ( https://hackage.haskell.org/package/proc )
process : Process libraries ( https://hackage.haskell.org/package/process )
process-extras : Process extras ( https://github.com/seereason/process-extras )
proctest : An IO library for testing interactive command line programs ( https://github.com/nh2/proctest )
product-isomorphic : Weaken applicative functor on products ( https://github.com/khibino/haskell-product-isomorphic )
product-profunctors : product-profunctors haskell library ( https://github.com/tomjaguarpaw/product-profunctors )
prof2dot : Convert GHC profiles into GraphViz's dot format ( http://antiope.com/downloads.html )
profiteur : Treemap visualiser for GHC prof files ( https://github.com/jaspervdj/profiteur )
profunctor-extras : This package has been absorbed into profunctors 4.0 ( https://github.com/ekmett/profunctor-extras/ )
profunctors : Profunctors ( https://github.com/ekmett/profunctors/ )
project-template : Specify Haskell project templates and generate files ( https://github.com/fpco/haskell-ide )
protocol-buffers : Parse Google Protocol Buffer specifications ( https://github.com/k-bx/protocol-buffers )
protocol-buffers-descriptor : Haskell implementation of the Google Protocol Buffer specification ( https://github.com/k-bx/protocol-buffers )
protolude : A small prelude ( https://github.com/sdiehl/protolude )
pseudomacros : cpp-style built-in macros using Template Haskell ( https://hackage.haskell.org/package/pseudomacros )
psqueue : Priority Search Queue ( https://hackage.haskell.org/package/PSQueue )
psqueues : Pure priority search queues ( https://hackage.haskell.org/package/psqueues )
publicsuffixlist : Is a given string a domain suffix? ( https://github.com/litherum/publicsuffixlist )
pulseaudio : A low-level (incomplete) wrapper around the pulseaudio client asynchronous api ( https://hackage.haskell.org/package/pulseaudio )
punycode : Encode unicode strings to ascii forms according to RFC 3492 ( https://github.com/litherum/punycode )
purebred-email : types and parser for email messages (including MIME) ( https://github.com/purebred-mua/purebred-email )
puremd5 : A Haskell-only implementation of the MD5 digest (hash) algorithm ( https://hackage.haskell.org/package/pureMD5 )
pvar : Mutable variable with primitive values ( https://github.com/lehins/pvar#readme )
pwstore-fast : Secure password storage ( https://github.com/PeterScott/pwstore )
pwstore-purehaskell : Secure password storage, in pure Haskell ( https://github.com/PeterScott/pwstore )
pyf : Quasiquotations for a python like interpolated string formatter ( https://hackage.haskell.org/package/PyF )
python-pickle : Serialization/deserialization using Python Pickle format ( https://hackage.haskell.org/package/python-pickle )
qr-imager : Library to generate images ( https://github.com/vmchale/QRImager#readme )
quickcheck : Automatic testing of Haskell programs ( https://github.com/nick8325/quickcheck )
quickcheck-arbitrary-template : Generate QuickCheck Gen for Sum Types ( https://github.com/plow-technologies/quickcheck-arbitrary-template#readme )
quickcheck-assertions : HUnit like assertions for QuickCheck ( https://github.com/s9gf4ult/quickcheck-assertions )
quickcheck-classes : QuickCheck common typeclasses ( https://github.com/andrewthad/quickcheck-classes#readme )
quickcheck-classes-base : QuickCheck common typeclasses from 'base' ( https://github.com/andrewthad/quickcheck-classes#readme )
quickcheck-instances : Common quickcheck instances ( https://github.com/haskellari/qc-instances )
quickcheck-io : Use HUnit assertions as QuickCheck properties ( https://github.com/hspec/quickcheck-io#readme )
quickcheck-properties : QuickCheck properties for standard type classes ( https://hackage.haskell.org/package/quickcheck-properties )
quickcheck-safe : Safe reimplementation of QuickCheck's core ( https://hackage.haskell.org/package/QuickCheck-safe )
quickcheck-simple : Test properties and default-mains for QuickCheck ( https://hackage.haskell.org/package/quickcheck-simple )
quickcheck-text : Alternative arbitrary instance for Text ( https://github.com/olorin/quickcheck-text )
quickcheck-unicode : Generator and shrink functions for testing Unicode-related software ( https://github.com/bos/quickcheck-unicode )
quickcheckvariant : Generator of \"valid\" and \"invalid\" data in a type class ( https://github.com/sanjorgek/QuickCheckVariant )
quicktest : A reflective batch tester for Haskell ( https://github.com/davidsiegel/quicktest )
quote-quot : Divide without division ( https://github.com/Bodigrim/quote-quot#readme )
random : Pseudo-random number generation ( https://hackage.haskell.org/package/random )
random-bytestring : Efficient generation of random bytestrings ( https://www.github.com/larskuhtz/random-bytestring )
random-fu : Random number generation ( https://github.com/mokus0/random-fu )
random-shuffle : Random shuffle implementation ( https://hackage.haskell.org/package/random-shuffle )
random-source : Generic basis for random number generators ( https://github.com/mokus0/random-fu )
ranged-sets : Ranged sets for Haskell ( https://github.com/PaulJohnson/Ranged-sets )
ranges : Ranges and various functions on them ( https://hackage.haskell.org/package/ranges )
rank1dynamic : Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types ( http://haskell-distributed.github.com )
rasterific : A pure haskell drawing engine ( https://hackage.haskell.org/package/Rasterific )
rate-limit : A basic library for rate-limiting IO actions ( https://github.com/acw/rate-limit )
ratio-int : Fast specialisation of Data.Ratio for Int ( https://github.com/RaphaelJ/ratio-int )
raw-strings-qq : Raw string literals for Haskell ( https://github.com/23Skidoo/raw-strings-qq )
rdf4h : A library for RDF processing in Haskell ( https://github.com/robstewart57/rdf4h )
rdtsc : Binding for the rdtsc machine instruction ( https://github.com/mgrabmueller/rdtsc )
re2 : Bindings to the re2 regular expression library ( https://github.com/rblaze/haskell-re2#readme )
reactive-banana : Library for functional reactive programming (FRP) ( https://wiki.haskell.org/Reactive-banana )
reactive-banana-gi-gtk : Simple reactive programming with GTK GObject Introspection ( https://github.com/mr/reactive-banana-gi-gtk )
reactive-banana-wx : Examples for the reactive-banana library, using wxHaskell ( http://wiki.haskell.org/Reactive-banana )
readable : Reading from Text and ByteString ( https://github.com/mightybyte/readable )
readargs : Simple command line argument parsing ( https://github.com/rampion/ReadArgs )
readline : An interface to the GNU readline library ( https://hackage.haskell.org/package/readline )
rebase : A more progressive alternative to the \"base\" package ( https://github.com/nikita-volkov/rebase )
recaptcha : Functions for using the reCAPTCHA service in web applications ( https://github.com/jgm/recaptcha/tree/master )
record-dot-preprocessor : Preprocessor to allow record.field syntax ( https://github.com/ndmitchell/record-dot-preprocessor#readme )
record-hasfield : A version of GHC.Records as available in future GHCs ( https://github.com/ndmitchell/record-hasfield#readme )
recursion-schemes : Representing common recursion patterns as higher-order functions ( https://github.com/ekmett/recursion-schemes/ )
redis : A driver for Redis key-value database ( http://hub.darcs.net/ganesh/redis )
reducers : Semigroups, specialized containers and a general map/reduce framework ( https://github.com/ekmett/reducers/ )
ref-tf : A type class for monads with references using type families ( https://hackage.haskell.org/package/ref-tf )
refact : Specify refactorings to perform with apply-refact ( https://hackage.haskell.org/package/refact )
refinery : Toolkit for building proof automation systems ( https://github.com/totbwf/refinery#readme )
reflection : Reifies arbitrary terms into types that can be reflected back into terms ( https://github.com/ekmett/reflection )
reflex : Higher-order Functional Reactive Programming ( https://reflex-frp.org )
reflex-backend-socket : Reflex bindings for TCP sockets ( https://github.com/qfpl/reflex-backend-socket/ )
reflex-libtelnet : Reflex bindings for libtelnet ( https://git.sr.ht/~jack/reflex-libtelnet )
reform : reform is a type-safe HTML form generation and validation library ( https://www.happstack.com/ )
reform-hamlet : Add support for using Hamlet with Reform ( http://www.happstack.com/ )
reform-happstack : Happstack support for reform ( https://www.happstack.com/ )
reform-hsp : Add support for using HSP with Reform ( http://www.happstack.com/ )
refserialize : Write to and read from ByteStrings maintaining internal memory references ( https://hackage.haskell.org/package/RefSerialize )
regex-applicative : Regex-based parsing with applicative interface ( https://github.com/feuerbach/regex-applicative )
regex-applicative-text : regex-applicative on text ( https://github.com/phadej/regex-applicative-text#readme )
regex-base : Common \"Text.Regex.*\" API for Regex matching ( https://wiki.haskell.org/Regular_expressions )
regex-compat : Replaces/enhances \"Text.Regex\" ( https://wiki.haskell.org/Regular_expressions )
regex-compat-tdfa : Unicode Support version of Text.Regex, using regex-tdfa ( http://hub.darcs.net/shelarcy/regex-compat-tdfa )
regex-pcre : PCRE Backend for \"Text.Regex\" (regex-base) ( https://wiki.haskell.org/Regular_expressions )
regex-pcre-builtin : PCRE Backend for \"Text.Regex\" (regex-base) ( https://hackage.haskell.org/package/regex-pcre-builtin )
regex-posix : POSIX Backend for \"Text.Regex\" (regex-base) ( https://hackage.haskell.org/package/regex-posix )
regex-tdfa : Pure Haskell Tagged DFA Backend for \"Text.Regex\" (regex-base) ( https://wiki.haskell.org/Regular_expressions )
regex-with-pcre : Toolkit for regex-base ( http://regex.uk )
regexpr : regular expression like Perl/Ruby in Haskell ( https://homepage3.nifty.com/salamander/second/projects/regexpr/ )
reinterpret-cast : Memory reinterpretation casts for Float/Double and Word32/Word64 ( https://github.com/nh2/reinterpret-cast )
relational-query : Typeful, Modular, Relational, algebraic query engine ( http://khibino.github.io/haskell-relational-record/ )
relational-query-hdbc : HDBC instance of relational-query and typed query interface for HDBC ( http://khibino.github.io/haskell-relational-record/ )
relational-record : Meta package of Relational Record ( http://khibino.github.io/haskell-relational-record/ )
relational-schemas : RDBMSs' schema templates for relational-query ( http://khibino.github.io/haskell-relational-record/ )
relude : Safe, performant, user-friendly and lightweight Haskell Standard Library ( https://github.com/kowainik/relude )
rematch : A simple api for matchers ( https://hackage.haskell.org/package/rematch )
repa : High performance, regular, shape polymorphic parallel arrays ( http://repa.ouroborus.net )
repa-algorithms : Algorithms using the Repa array library ( http://repa.ouroborus.net )
repa-devil : Support for image reading and writing of Repa arrays using in-place FFI calls ( https://github.com/RaphaelJ/repa-devil )
repa-io : Read and write Repa arrays in various formats ( http://repa.ouroborus.net )
repline : Haskeline wrapper for GHCi-like REPL interfaces ( https://github.com/sdiehl/repline )
rere : Regular-expressions extended with fixpoints for context-free powers ( https://hackage.haskell.org/package/rere )
rerebase : Reexports from \"base\" with a bunch of other standard libraries ( https://github.com/nikita-volkov/rerebase )
resolv : Domain Name Service (DNS) lookup via the libresolv standard library routines ( https://hackage.haskell.org/package/resolv )
resource-pool : A high-performance striped resource pooling implementation ( https://hackage.haskell.org/package/resource-pool )
resourcet : Deterministic allocation and freeing of scarce resources ( https://github.com/snoyberg/conduit )
rest-rewrite : Rewriting library with online termination checking ( https://hackage.haskell.org/package/rest-rewrite )
retrie : A powerful, easy-to-use codemodding tool for Haskell ( https://github.com/facebookincubator/retrie )
retry : Retry combinators for monadic actions that may fail ( https://github.com/Soostone/retry )
rfc5051 : Simple unicode collation as per RFC5051 ( https://hackage.haskell.org/package/rfc5051 )
riff : RIFF parser for Haskell ( https://bitbucket.org/robertmassaioli/riff/overview )
rio : A standard library for Haskell ( https://github.com/commercialhaskell/rio#readme )
rio-orphans : Orphan instances for the RIO type in the rio package ( https://github.com/commercialhaskell/rio#readme )
rio-prettyprint : Pretty-printing for RIO ( https://github.com/commercialhaskell/rio-prettyprint#readme )
roles : Composable class-based roles ( https://github.com/matt-noonan/roles/ )
rolling-queue : Bounded channel for STM that discards old entries when full ( https://github.com/joeyadams/haskell-rolling-queue )
roman-numerals : Parsing and pretty printing of Roman numerals ( https://github.com/roelvandijk/roman-numerals )
rope-utf16-splay : Ropes optimised for updating using UTF-16 code units and row/column pairs ( https://github.com/ollef/rope-utf16-splay )
rosezipper : Generic zipper implementation for Data.Tree ( https://hackage.haskell.org/package/rosezipper )
rotating-log : Size-limited, concurrent, automatically-rotating log writer ( https://github.com/Soostone/rotating-log )
row-types : Open Records and Variants ( https://github.com/dwincort/row-types )
rsa : Implementation of RSA, using the padding schemes of PKCS#1 v2.1 ( https://hackage.haskell.org/package/RSA )
rss : A library for generating RSS 2.0 feeds ( https://github.com/hvr/rss )
run-st : runST without boxing penalty ( https://github.com/andrewthad/run-st )
rvar : Random Variables ( https://github.com/haskell-numerics/random-fu )
safe : Library of safe (exception free) functions ( https://github.com/ndmitchell/safe#readme )
safe-exceptions : Safe, consistent, and easy exception handling ( https://github.com/fpco/safe-exceptions#readme )
safecopy : Binary serialization with version control ( https://github.com/acid-state/safecopy )
safesemaphore : Much safer replacement for QSemN, QSem, and SampleVar ( https://github.com/ChrisKuklewicz/SafeSemaphore )
saltine : Cryptography that's easy to digest (NaCl/libsodium bindings) ( https://hackage.haskell.org/package/saltine )
sample-frame : Handling of samples in an (audio) signal ( https://www.haskell.org/haskellwiki/Synthesizer )
sample-frame-np : Orphan instances for types from sample-frame and numericprelude ( https://www.haskell.org/haskellwiki/Synthesizer )
samtools : Binding to the C samtools library ( http://www.ingolia-lab.org/samtools-tutorial.html )
sandi : Data encoding library ( https://hackage.haskell.org/package/sandi )
sandwich : Yet another test framework for Haskell ( https://codedownio.github.io/sandwich )
say : Initial project template from stack ( https://github.com/fpco/say#readme )
sbv : SMT Based Verification: Symbolic Haskell theorem prover using SMT solving ( http://leventerkok.github.com/sbv/ )
sbvplugin : Formally prove properties of Haskell programs using SBV/SMT ( https://github.com/LeventErkok/sbvPlugin )
scalpel : A high level web scraping library for Haskell ( https://github.com/fimad/scalpel )
scalpel-core : A high level web scraping library for Haskell ( https://github.com/fimad/scalpel )
scanner : Fast non-backtracking incremental combinator parsing for bytestrings ( https://github.com/Yuras/scanner )
scheduler : Work stealing scheduler ( https://github.com/lehins/haskell-scheduler )
scientific : Numbers represented using scientific notation ( https://github.com/basvandijk/scientific )
scotty : Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp ( https://github.com/scotty-web/scotty )
scrypt : Stronger password hashing via sequential memory-hard functions ( https://github.com/informatikr/scrypt )
sdl-gfx : Binding to libSDL_gfx ( https://hackage.haskell.org/package/SDL-gfx )
sdl-image : Binding to libSDL_image ( https://hackage.haskell.org/package/SDL-image )
sdl-mixer : Binding to libSDL_mixer ( https://hackage.haskell.org/package/SDL-mixer )
sdl-ttf : Binding to libSDL_ttf ( https://hackage.haskell.org/package/SDL-ttf )
sdl2 : Both high- and low-level bindings to the SDL library (version 2.0.6+) ( https://hackage.haskell.org/package/sdl2 )
sdl2-image : Bindings to SDL2_image ( https://hackage.haskell.org/package/sdl2-image )
sdl2-mixer : Bindings to SDL2_mixer ( https://hackage.haskell.org/package/sdl2-mixer )
securemem : abstraction to an auto scrubbing and const time eq, memory chunk ( https://github.com/vincenthz/hs-securemem )
selective : Selective applicative functors ( https://github.com/snowleopard/selective )
semialign : Align and Zip type-classes from the common Semialign ancestor ( https://github.com/haskellari/these )
semigroupoid-extras : Semigroupoids that depend on PolyKinds ( https://github.com/ekmett/semigroupoid-extras )
semigroupoids : Semigroupoids: Category sans id ( https://github.com/ekmett/semigroupoids )
semigroups : Anything that associates ( https://github.com/ekmett/semigroups/ )
semirings : two monoids as one, in holy haskimony ( https://github.com/chessai/semirings )
semver : Representation, manipulation, and de/serialisation of Semantic Versions ( https://github.com/brendanhay/semver )
semver-range : An implementation of semver and semantic version ranges ( https://hackage.haskell.org/package/semver-range )
sendfile : A portable sendfile library ( http://hub.darcs.net/stepcut/sendfile )
seqloc : Handle sequence locations for bioinformatics ( http://www.ingolia-lab.org/seqloc-tutorial.html )
sequence-formats : A package with basic parsing utilities for several Bioinformatic data formats ( https://github.com/stschiff/sequence-formats )
serialise : A binary serialisation library for Haskell values ( https://github.com/well-typed/cborg )
serialport : Cross platform serial port library ( https://github.com/standardsemiconductor/serialport )
servant : A family of combinators for defining webservices APIs ( https://docs.servant.dev/ )
servant-client : Automatic derivation of querying functions for servant ( https://docs.servant.dev/ )
servant-client-core : Core functionality and class for client function generation for servant APIs ( https://docs.servant.dev/ )
servant-lucid : Servant support for lucid ( https://haskell-servant.readthedocs.org/ )
servant-server : A family of combinators for defining webservices APIs and serving them ( https://docs.servant.dev/ )
serversession : Secure, modular server-side sessions ( https://github.com/yesodweb/serversession )
serversession-backend-redis : Storage backend for serversession using Redis ( https://github.com/yesodweb/serversession )
setenv : A cross-platform library for setting environment variables ( https://hackage.haskell.org/package/setenv )
setlocale : Haskell bindings to setlocale ( https://gitlab.com/Kritzefitz/haskell-setlocale/ )
sfml-audio : minimal bindings to the audio module of sfml ( http://patch-tag.com/r/shahn/sfml-audio )
sha : Implementations of the SHA suite of message digest functions ( https://hackage.haskell.org/package/SHA )
shakespeare : A toolkit for making compile-time interpolated templates ( https://www.yesodweb.com/book/shakespearean-templates )
shakespeare-css : Stick your haskell variables into css at compile time. (deprecated) ( https://www.yesodweb.com/book/shakespearean-templates )
shakespeare-i18n : A type-based approach to internationalization. (deprecated) ( https://www.yesodweb.com/book/shakespearean-templates )
shakespeare-js : Stick your haskell variables into javascript/coffeescript at compile time ( https://www.yesodweb.com/book/shakespearean-templates )
shakespeare-text : Interpolation with quasi-quotation: put variables strings (deprecated) ( https://www.yesodweb.com/book/shakespearean-templates )
shell-conduit : Write shell scripts with Conduit ( https://github.com/psibi/shell-conduit )
shell-escape : Shell escaping library ( https://github.com/solidsnack/shell-escape )
shell-utility : Utility functions for writing command-line programs ( http://hub.darcs.net/thielema/shell-utility/ )
shellac : A framework for creating shell environments ( http://rwd.rdockins.name/shellac/home/ )
shellac-compatline : \"compatline\" backend module for Shellac ( http://rwd.rdockins.name/shellac/home/ )
shellac-editline : Editline backend module for Shellac ( http://rwd.rdockins.name/shellac/home/ )
shellac-readline : Readline backend module for Shellac ( http://rwd.rdockins.name/shellac/home/ )
shellwords : Parse strings into words, like a shell would ( https://github.com/pbrisbin/hs-shellwords#readme )
shelly : shell-like (systems) programming in Haskell ( https://github.com/gregwebs/Shelly.hs )
shh : Simple shell scripting from Haskell ( https://hackage.haskell.org/package/shh )
should-not-typecheck : A HUnit/hspec assertion library to verify that an expression does not typecheck ( https://github.com/CRogers/should-not-typecheck )
show : 'Show' instances for Lambdabot ( https://hackage.haskell.org/package/show )
show-combinators : Combinators to write Show instances ( https://github.com/Lysxia/show-combinators#readme )
show-please : A wrapper type V with improved Show instances ( https://github.com/ddssff/show-please )
sibe : Machine Learning algorithms ( https://github.com/mdibaiee/sibe )
signal : Multiplatform signal support for Haskell ( https://github.com/pmlodawski/signal )
silently : Prevent or capture writing to stdout and other handles ( https://github.com/hspec/silently )
simple-affine-space : A simple library for affine and vector spaces ( https://www.haskell.org/haskellwiki/Yampa )
simple-cabal : Cabal file wrapper library ( https://github.com/juhp/simple-cabal )
simple-cmd : Simple String-based process commands ( https://hackage.haskell.org/package/simple-cmd )
simple-cmd-args : Simple command args parsing and execution ( https://github.com/juhp/simple-cmd-args )
simple-log : Simple log for Haskell ( https://github.com/mvoidex/simple-log )
simple-neural-networks : Simple parallel neural networks implementation ( http://eax.me/haskell-neural-networks/ )
simple-reflect : Simple reflection of expressions containing variables ( http://twanvl.nl/blog/haskell/simple-reflection-of-expressions )
simple-sendfile : Cross platform library for the sendfile system call ( https://hackage.haskell.org/package/simple-sendfile )
simple-smt : A simple way to interact with an SMT solver process ( https://hackage.haskell.org/package/simple-smt )
simpleaes : Fast AES encryption/decryption for bytestrings ( https://hackage.haskell.org/package/SimpleAES )
simpleargs : Provides a more flexible getArgs function with better error reporting ( http://malde.org/~ketil/simpleargs )
singleton-bool : Type level booleans ( https://github.com/phadej/singleton-bool#readme )
singletons : Basic singleton types and definitions ( https://www.github.com/goldfirere/singletons )
singletons-base : A promoted and singled version of the base library ( https://www.github.com/goldfirere/singletons )
singletons-th : A framework for generating singleton types ( https://www.github.com/goldfirere/singletons )
size-based : Sized functors, for size-based enumerations ( https://hackage.haskell.org/package/size-based )
skein : Skein, a family of cryptographic hash functions. Includes Skein-MAC as well ( https://github.com/meteficha/skein )
skylighting : syntax highlighting library ( https://github.com/jgm/skylighting )
skylighting-core : syntax highlighting library ( https://github.com/jgm/skylighting )
skylighting-format-ansi : ANSI formatter for skylighting syntax highlighting library ( https://github.com/jgm/skylighting )
skylighting-format-blaze-html : HTML formatter for skylighting syntax highlighting library ( https://github.com/jgm/skylighting )
skylighting-format-context : ConTeXt formatter for skylighting syntax highlighting library ( https://github.com/jgm/skylighting )
skylighting-format-latex : LaTeX formatter for skylighting syntax highlighting library ( https://github.com/jgm/skylighting )
slave-thread : A fundamental solution to ghost threads and silent exceptions ( https://github.com/nikita-volkov/slave-thread )
smallcheck : A property-based testing library ( https://github.com/Bodigrim/smallcheck )
smtlib : A library for working with the SMTLIB format ( https://hackage.haskell.org/package/smtLib )
smtpclient : A simple SMTP client library ( https://hackage.haskell.org/package/SMTPClient )
snap : Top-level package for the Snap Web Framework ( https://snapframework.com/ )
snap-core : Snap: A Haskell Web Framework (core interfaces and types) ( https://snapframework.com/ )
snap-loader-dynamic : Snap dynamic loader ( http://snapframework.com/ )
snap-loader-static : Snap static loader ( http://snapframework.com/ )
snap-server : A web server for the Snap Framework ( https://snapframework.com/ )
snap-templates : Scaffolding CLI for the Snap Framework ( http://snapframework.com/ )
snaplet-sqlite-simple : sqlite-simple snaplet for the Snap Framework ( https://github.com/nurpax/snaplet-sqlite-simple )
sockaddr : Printing SockAddr ( https://hackage.haskell.org/package/sockaddr )
socket : An extensible socket library ( https://github.com/lpeterse/haskell-socket )
socket-sctp : STCP socket extensions library ( https://github.com/shlevy/haskell-socket-sctp )
socks : Socks proxy (version 5) implementation ( https://github.com/vincenthz/hs-socks )
soegtk : GUI functions as used in the book \"The Haskell School of Expression\" ( http://projects.haskell.org/gtk2hs/ )
sop-core : True Sums of Products ( https://hackage.haskell.org/package/sop-core )
sorted-list : Type-enforced sorted lists and related functions ( https://github.com/Daniel-Diaz/sorted-list/blob/master/README.md )
sourcemap : Implementation of source maps as proposed by Google and Mozilla ( https://hackage.haskell.org/package/sourcemap )
sox : Play, write, read, convert audio signals using Sox ( https://www.haskell.org/haskellwiki/Sox )
spdx : SPDX license expression language, Extras ( https://github.com/phadej/spdx )
special-values : Typeclass providing special values ( https://github.com/minad/special-values#readme )
speculation : A framework for safe, programmable, speculative parallelism ( https://github.com/ekmett/speculation )
sphinx : Haskell bindings to the Sphinx full-text searching daemon ( https://github.com/gregwebs/haskell-sphinx-client )
spintax : Random text generation based on spintax ( https://github.com/MichelBoucey/spintax )
split : Combinator library for splitting lists ( https://hackage.haskell.org/package/split )
splitmix : Fast Splittable PRNG ( https://hackage.haskell.org/package/splitmix )
spool : Convert between ByteString and Vector.Storable without copying ( https://hackage.haskell.org/package/spool )
spoon : Catch errors thrown from pure computations ( https://hackage.haskell.org/package/spoon )
sql-words : Simple idea SQL keywords data constructor into OverloadedString ( http://khibino.github.io/haskell-relational-record/ )
sqlite-simple : Mid-Level SQLite client library ( https://github.com/nurpax/sqlite-simple )
sqlite-simple-errors : Light wrapper around errors from sqlite-simple ( https://github.com/caneroj1/sqlite-simple-errors )
srcloc : Data types for managing source code locations ( https://github.com/mainland/srcloc )
ssh-known-hosts : Read and interpret the SSH known-hosts file ( http://hub.darcs.net/kquick/ssh-known-hosts )
stack : The Haskell Tool Stack ( https://github.com/commercialhaskell/stack )
stack-bin : The Haskell Tool Stack (Binary) ( https://github.com/commercialhaskell/stack )
stateref : Abstraction for things that work like IORef ( https://hackage.haskell.org/package/stateref )
statestack : Simple State-like monad transformer with saveable and restorable state ( https://hackage.haskell.org/package/statestack )
statevar : State variables ( https://github.com/haskell-opengl/StateVar )
static-bytes : A Haskell library providing types representing various byte sizes of data ( https://github.com/commercialhaskell/static-bytes#readme )
static-hash : Immutable hash ( https://hackage.haskell.org/package/static-hash )
statistics : A library of statistical types, data, and functions ( https://github.com/haskell/statistics )
status-notifier-item : A wrapper over the StatusNotifierItem/libappindicator dbus specification ( https://github.com/IvanMalison/status-notifier-item#readme )
statvfs : Get unix filesystem statistics with statfs, statvfs ( https://hackage.haskell.org/package/statvfs )
stb-image-redux : Image loading and writing microlibrary ( https://github.com/sasinestro/stb-image-redux#readme )
stemmer : Haskell bindings to the Snowball stemming library ( http://www.github.com/bgamari/stemmer )
stickykeyshotkey : get and set STICKYKEYS.SKF_HOTKEYACTIVE ( https://hackage.haskell.org/package/stickyKeysHotKey )
stm : Software Transactional Memory ( https://wiki.haskell.org/Software_transactional_memory )
stm-chans : Additional types of channels for STM ( http://code.haskell.org/~wren/ )
stm-conduit : Introduces conduits to channels, and promotes using conduits concurrently ( https://github.com/cgaebel/stm-conduit )
stm-containers : Containers for STM ( https://github.com/nikita-volkov/stm-containers )
stm-delay : Updatable one-shot timer polled with STM ( https://github.com/joeyadams/haskell-stm-delay )
stm-hamt : STM-specialised Hash Array Mapped Trie ( https://github.com/nikita-volkov/stm-hamt )
stm-linkedlist : Mutable, doubly linked lists for STM ( https://hackage.haskell.org/package/stm-linkedlist )
stm-split : TMVars, TVars and TChans with distinguished input and output side ( https://hackage.haskell.org/package/stm-split )
stmonadtrans : A monad transformer version of the ST monad ( https://hackage.haskell.org/package/STMonadTrans )
storable-complex : Storable instance for Complex ( https://github.com/cartazio/storable-complex )
storable-record : Elegant definition of Storable instances for records ( https://code.haskell.org/~thielema/storable-record/ )
storable-tuple : Storable instance for pairs and triples ( http://code.haskell.org/~thielema/storable-tuple/ )
storablevector : Fast, packed, strict storable arrays with a list interface like ByteString ( https://www.haskell.org/haskellwiki/Storable_Vector )
store : Fast binary serialization ( https://github.com/mgsloan/store#readme )
store-core : Fast and lightweight binary serialization ( https://github.com/fpco/store#readme )
stream : A library for manipulating infinite lists ( https://hackage.haskell.org/package/Stream )
streaming : an elementary streaming prelude and general stream type ( https://github.com/haskell-streaming/streaming )
streaming-commons : Common lower-level functions needed by various streaming data libraries ( https://github.com/fpco/streaming-commons )
streamly : Dataflow programming and declarative concurrency ( https://streamly.composewell.com )
strict : Strict data types and String IO ( https://github.com/haskell-strict/strict )
strict-identity : Strict Identity Monad, handy for writing fast code! ( https://github.com/cartazio/strict-identity )
strict-list : Strict linked list ( https://github.com/nikita-volkov/strict-list )
strictify : Find a local optimum of strictness annotations ( https://hackage.haskell.org/package/strictify )
string-class : String class library ( https://github.com/string-class/string-class )
string-conv : Standardized conversion between string types ( https://github.com/Soostone/string-conv )
string-conversions : Simplifies dealing with different types for strings ( https://github.com/soenkehahn/string-conversions#readme )
string-interpolate : Haskell string/text/bytestring interpolation that just works ( https://gitlab.com/williamyaoh/string-interpolate/blob/master/README.md )
string-qq : QuasiQuoter for non-interpolated strings, texts and bytestrings ( https://hackage.haskell.org/package/string-qq )
stringable : A Stringable type class, in the spirit of Foldable and Traversable ( https://hackage.haskell.org/package/stringable )
stringbuilder : A writer monad for multi-line string literals ( https://hackage.haskell.org/package/stringbuilder )
stringprep : Implements the \"StringPrep\" algorithm ( https://hackage.haskell.org/package/stringprep )
stringsearch : Fast searching, splitting and replacing of ByteStrings ( https://bitbucket.org/dafis/stringsearch )
strptime : Efficient parsing of LocalTime using a binding to C's strptime ( https://hackage.haskell.org/package/strptime )
structured : Structure (hash) of your data types ( https://hackage.haskell.org/package/structured )
stylish-haskell : Haskell code prettifier ( https://github.com/haskell/stylish-haskell )
styx : A generator of nix files ( https://hackage.haskell.org/package/styx )
suffixtree : Efficient, lazy suffix tree implementation ( https://github.com/bos/suffixtree )
suitable : Abstract over the constraints on the parameters to type constructors ( https://hackage.haskell.org/package/suitable )
superdoc : Additional documentation markup and Unicode support ( http://www.mathstat.dal.ca/~selinger/superdoc/ )
svg-builder : DSL for building SVG ( https://github.com/diagrams/svg-builder.git )
svgcairo : Binding to the libsvg-cairo library ( http://projects.haskell.org/gtk2hs/ )
svgfonts : Fonts from the SVG-Font format ( https://hackage.haskell.org/package/SVGFonts )
syb-with-class : Scrap Your Boilerplate With Class ( https://hackage.haskell.org/package/syb-with-class )
syb-with-class-instances-text : Scrap Your Boilerplate With Class Text instance ( https://hackage.haskell.org/package/syb-with-class-instances-text )
symbol : A 'Symbol' type for fast symbol comparison ( http://www.cs.drexel.edu/~mainland/ )
synthesizer-alsa : Control synthesizer effects via ALSA/MIDI ( https://www.haskell.org/haskellwiki/Synthesizer )
synthesizer-core : Audio signal processing coded in Haskell: Low level part ( https://www.haskell.org/haskellwiki/Synthesizer )
synthesizer-dimensional : Audio signal processing with static physical dimensions ( https://www.haskell.org/haskellwiki/Synthesizer )
synthesizer-midi : Render audio signals from MIDI files or realtime messages ( https://www.haskell.org/haskellwiki/Synthesizer )
system-argv0 : Get argv[0] as a FilePath ( https://john-millikin.com/software/haskell-filesystem/ )
system-fileio : Consistent filesystem interaction across GHC versions (deprecated) ( https://github.com/fpco/haskell-filesystem )
system-filepath : High-level, byte-based file and directory path manipulations (deprecated) ( https://github.com/fpco/haskell-filesystem )
system-info : Get the name of the operating system ( https://github.com/ChaosGroup/system-info#readme )
system-posix-redirect : A toy module to temporarily redirect a program's stdout ( https://hackage.haskell.org/package/system-posix-redirect )
system-time-monotonic : Simple library for using the system's monotonic clock ( https://github.com/joeyadams/haskell-system-time-monotonic )
system-uuid : Bindings to system UUID functions ( https://github.com/solidsnack/system-uuid/ )
syz : Scrap Your Zippers ( http://www.cs.indiana.edu/~adamsmd/papers/scrap_your_zippers/ )
tabular : Two-dimensional data tables with rendering functions ( https://github.com/bgamari/tabular )
tag-bits : Provides access to the dynamic pointer tagging bits used by GHC ( https://github.com/ekmett/tag-bits )
tagged : Haskell 98 phantom types to avoid unsafely passing dummy arguments ( https://github.com/ekmett/tagged )
tagged-transformer : Provides newtype wrappers for phantom types ( https://github.com/ekmett/tagged-transformer )
tagshare : TagShare - explicit sharing with tags ( https://hackage.haskell.org/package/tagshare )
tagsoup : Parsing and extracting information from (possibly malformed) HTML/XML documents ( https://github.com/ndmitchell/tagsoup#readme )
tagsoup-parsec : Tokenizes Tag, so [ Tag ] can be used as parser input ( http://www.killersmurf.com )
tagstream-conduit : streamlined html tag parser ( https://github.com/yihuang/tagstream-conduit )
tar : Reading, writing and manipulating \".tar\" archive files ( https://hackage.haskell.org/package/tar )
tar-conduit : Extract and create tar files using conduit for streaming ( https://github.com/snoyberg/tar-conduit#readme )
tardis : Bidirectional state monad transformer ( https://github.com/DanBurton/tardis )
tasty : Modern and extensible testing framework ( https://github.com/UnkindPartition/tasty )
tasty-ant-xml : Render tasty output to XML for Jenkins ( https://github.com/ocharles/tasty-ant-xml )
tasty-discover : Test discovery for the tasty framework ( https://github.com/haskell-works/tasty-discover )
tasty-expected-failure : Mark tasty tests as failure expected ( https://github.com/nomeata/tasty-expected-failure )
tasty-golden : Golden tests support for tasty ( https://github.com/UnkindPartition/tasty-golden )
tasty-hedgehog : Integration for tasty and hedgehog ( https://github.com/qfpl/tasty-hedgehog )
tasty-hslua : Tasty helpers to test HsLua ( https://hslua.org/ )
tasty-hspec : Hspec support for the Tasty test framework ( https://github.com/mitchellwrosen/tasty-hspec )
tasty-hunit : HUnit support for the Tasty test framework ( https://github.com/feuerbach/tasty )
tasty-inspection-testing : Inspection testing support for tasty ( https://github.com/Bodigrim/tasty-inspection-testing )
tasty-kat : Known Answer Tests (KAT) framework for tasty ( https://github.com/vincenthz/tasty-kat )
tasty-lua : Write tests in Lua, integrate into tasty ( https://github.com/hslua/hslua )
tasty-quickcheck : QuickCheck support for the Tasty test framework ( https://github.com/UnkindPartition/tasty )
tasty-rerun : Rerun only tests which failed in a previous test run ( https://github.com/ocharles/tasty-rerun )
tasty-silver : A fancy test runner, including support for golden tests ( https://github.com/phile314/tasty-silver )
tasty-smallcheck : SmallCheck support for the Tasty test framework ( https://github.com/feuerbach/tasty )
tasty-th : Automatic tasty test case discovery using TH ( https://github.com/bennofs/tasty-th )
tasty-travis : Fancy Travis CI output for tasty tests ( https://github.com/merijn/tasty-travis )
tcache : A Transactional cache with user-defined persistence ( https://hackage.haskell.org/package/TCache )
tcp-streams : One stop solution for tcp client and server with tls support ( https://github.com/didi-FP/tcp-streams )
tcp-streams-openssl : Tcp streams using openssl for tls support ( https://github.com/didi-FP/tcp-streams )
tdigest : On-line accumulation of rank-based statistics ( https://github.com/phadej/haskell-tdigest#readme )
template : Simple string substitution ( https://hackage.haskell.org/package/template )
template-haskell-compat-v0208 : Backward-compatibility layer for Template Haskell newer than 2.8 ( https://github.com/nikita-volkov/template-haskell-compat-v0208 )
temporary : Portable temporary file and directory support ( https://github.com/feuerbach/temporary )
temporary-rc : Portable temporary file and directory support for Windows and Unix ( https://github.com/feuerbach/temporary )
terminal-progress-bar : A simple progress bar in the terminal ( https://github.com/roelvandijk/terminal-progress-bar )
terminal-size : Get terminal window height and width ( https://hackage.haskell.org/package/terminal-size )
terminfo-hs : A pure-Haskell (no FFI) module for accessing terminfo databases ( https://hackage.haskell.org/package/terminfo-hs )
test-framework : Framework for running and organising tests, with HUnit and QuickCheck support ( https://haskell.github.io/test-framework/ )
test-framework-hunit : HUnit support for the test-framework package ( https://batterseapower.github.io/test-framework/ )
test-framework-leancheck : LeanCheck support for test-framework ( https://github.com/rudymatela/test-framework-leancheck#readme )
test-framework-quickcheck2 : QuickCheck2 support for the test-framework package ( http://haskell.github.io/test-framework/ )
test-framework-smallcheck : Support for SmallCheck tests in test-framework ( https://github.com/feuerbach/smallcheck )
test-framework-th : Automagically generate the HUnit and Quickcheck using Template Haskell ( https://github.com/finnsson/test-generator )
testing-feat : Functional Enumeration of Algebraic Types ( https://github.com/JonasDuregard/testing-feat )
testing-type-modifiers : Data type modifiers for property based testing ( https://hackage.haskell.org/package/testing-type-modifiers )
texmath : Conversion between math formats ( https://github.com/jgm/texmath )
texrunner : Functions for running Tex from Haskell ( https://hackage.haskell.org/package/texrunner )
text : An efficient packed Unicode text type ( https://github.com/haskell/text )
text-ansi : Text styling for ANSI terminals ( https://github.com/awkward-squad/text-ansi )
text-binary : Binary instances for text types ( https://github.com/kawu/text-binary )
text-builder : Efficient strict text builder ( https://github.com/nikita-volkov/text-builder )
text-builder-dev : Edge of developments for \"text-builder\" ( https://github.com/nikita-volkov/text-builder-dev )
text-builder-linear : Builder for Text and ByteString based on linear types ( https://github.com/Bodigrim/linear-builder )
text-conversions : Safe conversions between textual types ( https://github.com/cjdev/text-conversions )
text-format : Text formatting ( https://github.com/bos/text-format )
text-format-simple : Simple text formatting library ( https://hackage.haskell.org/package/text-format-simple )
text-icu : Bindings to the ICU library ( https://github.com/haskell/text-icu )
text-icu-normalized : Dealing with Strict Text in NFC normalization ( https://gitlab.com/theunixman/text-icu-normalized )
text-iso8601 : Converting time to and from ISO 8601 text ( https://github.com/haskell/aeson )
text-latin1 : Latin-1 (including ASCII) utility functions ( https://github.com/mvv/text-latin1 )
text-manipulate : Case conversion, word boundary manipulation, and textual subjugation ( https://github.com/brendanhay/text-manipulate )
text-metrics : Calculate various string metrics efficiently ( https://github.com/mrkkrp/text-metrics )
text-postgresql : Parser and Printer of PostgreSQL extended types ( http://khibino.github.io/haskell-relational-record/ )
text-printer : Abstract interface for text builders/printers ( https://github.com/mvv/text-printer )
text-region : Marking text regions ( https://github.com/mvoidex/text-region )
text-rope : Text lines and ropes ( https://github.com/Bodigrim/text-rope )
text-short : Memory-efficient representation of Unicode text strings ( https://hackage.haskell.org/package/text-short )
text-show : Efficient conversion of values into Text ( https://github.com/RyanGlScott/text-show )
text-stream-decode : Streaming decoding functions for UTF encodings. (deprecated) ( https://github.com/fpco/text-stream-decode )
text-zipper : A text editor zipper library ( https://github.com/jtdaugherty/text-zipper/ )
tf-random : High-quality splittable pseudorandom number generator ( https://hackage.haskell.org/package/tf-random )
tga : Reading and writing of tga image files ( https://hackage.haskell.org/package/tga )
th-abstraction : Nicer interface for reified information about data types ( https://github.com/glguy/th-abstraction )
th-compat : Backward- (and forward-)compatible Quote and Code types ( https://github.com/haskell-compat/th-compat )
th-constraint-compat : Compatibility for type constraint template ( https://hackage.haskell.org/package/th-constraint-compat )
th-data-compat : Compatibility for data definition template of TH ( https://hackage.haskell.org/package/th-data-compat )
th-desugar : Functions to desugar Template Haskell ( https://github.com/goldfirere/th-desugar )
th-env : Template Haskell splices that expand to an environment variable ( https://github.com/dzhus/th-env#readme )
th-expand-syns : Expands type synonyms in Template Haskell ASTs ( https://github.com/DanielSchuessler/th-expand-syns )
th-extras : A grab bag of functions for use with Template Haskell ( https://github.com/mokus0/th-extras )
th-lift : Derive Template Haskell's Lift class for datatypes ( https://github.com/RyanGlScott/th-lift )
th-lift-instances : Lift instances for template-haskell for common data types ( https://github.com/bennofs/th-lift-instances/ )
th-orphans : Orphan instances for TH datatypes ( https://hackage.haskell.org/package/th-orphans )
th-reify-compat : Compatibility for the result type of TH reify ( https://github.com/khibino/haskell-th-reify-compat/ )
th-reify-many : Recurseively reify template haskell datatype info ( https://github.com/mgsloan/th-reify-many )
th-utilities : Collection of useful functions for use with Template Haskell ( https://github.com/fpco/th-utilities#readme )
themoviedb : Haskell API bindings for http://themoviedb.org ( https://github.com/pjones/themoviedb )
these : An either-or-both data type ( https://github.com/haskellari/these )
these-lens : Lenses for These ( https://github.com/haskellari/these )
threads : Fork threads and wait for their result ( https://github.com/basvandijk/threads )
threepenny-gui : GUI framework that uses the web browser as a display ( https://wiki.haskell.org/Threepenny-gui )
tidal : Pattern language for improvised music ( https://tidalcycles.org/ )
time-compat : Compatibility package for time ( https://github.com/haskellari/time-compat )
time-lens : Lens-based interface to Data.Time data structures ( https://github.com/feuerbach/time-lens )
time-locale-compat : Compatibility of TimeLocale between old-locale and time-1.5 ( https://github.com/khibino/haskell-time-locale-compat )
time-manager : Scalable timer ( https://github.com/yesodweb/wai )
time-parsers : Parsers for types in 'time' ( https://github.com/phadej/time-parsers#readme )
time-units : A basic library for defining units of time as types ( https://github.com/acw/time-units )
timeplot : A tool for visualizing time series from log files ( http://haskell.org/haskellwiki/Timeplot )
timerep : Parse and display time according to some RFCs (RFC3339, RFC2822, RFC822) ( https://github.com/HugoDaniel/timerep )
timespan : Useful timespan datatype and functions ( https://github.com/agrafix/timespan#readme )
timezone-olson : A pure Haskell parser and renderer for binary Olson timezone files ( https://projects.haskell.org/time-ng/ )
timezone-series : Enhanced timezone handling for Data.Time ( https://projects.haskell.org/time-ng/ )
tls : TLS/SSL protocol native implementation (Server and Client) ( https://github.com/haskell-tls/hs-tls )
tls-session-manager : In-memory TLS session manager ( https://hackage.haskell.org/package/tls-session-manager )
tmp-postgres : Start and stop a temporary postgres ( https://github.com/jfischoff/tmp-postgres#readme )
toml-parser : TOML 1.0.0 parser ( https://hackage.haskell.org/package/toml-parser )
tomland : Bidirectional TOML serialization ( https://github.com/kowainik/tomland )
top : Constraint solving framework employed by the Helium Compiler ( http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome )
topograph : Directed acyclic graphs ( https://github.com/phadej/topograph )
torrent : BitTorrent file parser and generator ( https://hackage.haskell.org/package/torrent )
torsor : Torsor Typeclass ( https://github.com/andrewthad/torsor#readme )
transformers : Concrete functor and monad transformers ( https://hackage.haskell.org/package/transformers )
transformers-base : Lift computations from the bottom of a transformer stack ( https://github.com/mvv/transformers-base )
transformers-compat : A small compatibility shim for the transformers library ( https://github.com/ekmett/transformers-compat/ )
transformers-free : Free monad transformers ( https://hackage.haskell.org/package/transformers-free )
traverse-with-class : Generic applicative traversals ( https://hackage.haskell.org/package/traverse-with-class )
tree-diff : Diffing of (expression) trees ( https://github.com/phadej/tree-diff )
tree-traversals : Functions and newtype wrappers for traversing Trees ( https://github.com/rampion/tree-traversals )
trial : Trial Data Structure ( https://github.com/kowainik/trial )
trial-optparse-applicative : Trial helper functions for optparse-applicative ( https://github.com/kowainik/trial )
trial-tomland : Trial helper functions for tomland ( https://github.com/kowainik/trial )
trifecta : A modern parser combinator library with convenient diagnostics ( https://github.com/ekmett/trifecta/ )
ttrie : Contention-free STM hash map ( https://github.com/mcschroeder/ttrie )
tuple : Various functions on tuples ( https://hackage.haskell.org/package/tuple )
tuple-th : Generate (non-recursive) utility functions for tuples of statically known size ( https://hackage.haskell.org/package/tuple-th )
tuples : Small monomorphic tuples ( https://github.com/andrewthad/tuples )
turtle : Shell programming, Haskell-style ( https://hackage.haskell.org/package/turtle )
txt-sushi : The SQL link in your *NIX chain ( http://keithsheppard.name/txt-sushi )
type-aligned : Various type-aligned sequence data structures ( https://github.com/atzeus/type-aligned )
type-equality : Type equality, coercion/cast and other operations ( https://github.com/hesselink/type-equality )
type-equality-check : Type equality check ( http://darcs.wolfgang.jeltsch.info/haskell/type-equality-check )
type-errors : Tools for writing better type errors ( https://github.com/isovector/type-errors#readme )
type-errors-pretty : Combinators for writing pretty type errors easily ( https://github.com/chshersh/type-errors-pretty )
type-functions : Emulation of type-level functions ( http://darcs.wolfgang.jeltsch.info/haskell/type-functions )
type-hint : Guide type inference with proxy values ( https://github.com/mvv/type-hint )
type-level : Type-level programming library ( http://code.haskell.org/type-level )
type-level-numbers : Type level numbers implemented using type families ( https://hackage.haskell.org/package/type-level-numbers )
type-operators : Various type-level operators ( https://github.com/Shou/type-operators#readme )
typecompose : Type composition classes and instances ( https://github.com/conal/TypeCompose )
typed-process : Run external processes, with strong typing of streams ( https://github.com/fpco/typed-process )
typelits-witnesses : Existential witnesses, singletons, and classes for operations on GHC TypeLits ( https://github.com/mstksg/typelits-witnesses )
typerep-map : Efficient implementation of a dependent map with types as keys ( https://github.com/kowainik/typerep-map )
typst : Parsing and evaluating typst syntax ( https://hackage.haskell.org/package/typst )
typst-symbols : Symbol and emoji lookup for typst language ( https://github.com/jgm/typst-symbols )
tz : Efficient time zone handling ( https://github.com/ysangkok/haskell-tz )
tzdata : Time zone database (as files and as a module) ( https://github.com/ysangkok/haskell-tzdata )
uglymemo : A simple (but internally ugly) memoization function ( https://hackage.haskell.org/package/uglymemo )
unagi-chan : Fast concurrent queues with a Chan-like API, and more ( https://hackage.haskell.org/package/unagi-chan )
unbounded-delays : Unbounded thread delays and timeouts ( https://github.com/basvandijk/unbounded-delays )
unboxing-vector : A newtype-friendly variant of unboxed vectors ( https://github.com/minoki/unboxing-vector#readme )
unexceptionalio : IO without any non-error, synchronous exceptions ( https://github.com/singpolyma/unexceptionalio )
unexceptionalio-trans : A wrapper around UnexceptionalIO using monad transformers ( https://github.com/singpolyma/unexceptionalio-trans )
unicode-collation : Haskell implementation of the Unicode Collation Algorithm ( https://github.com/jgm/unicode-collation )
unicode-data : Access Unicode Character Database (UCD) ( https://github.com/composewell/unicode-data )
unicode-transforms : Unicode normalization ( https://github.com/composewell/unicode-transforms )
unification-fd : Simple generic unification algorithms ( http://code.haskell.org/~wren/ )
union-find : Efficient union and equivalence testing of sets ( https://github.com/nominolo/union-find )
uniplate : Help writing simple, concise and fast generic operations ( https://github.com/ndmitchell/uniplate#readme )
uniqueid : Splittable Unique Identifier Supply ( https://github.com/sebfisch/uniqueid/wikis )
units : A domain-specific type system for dimensional analysis ( https://github.com/goldfirere/units )
units-parser : A parser for units of measure ( https://hackage.haskell.org/package/units-parser )
universe-base : A class for finite and recursively enumerable types ( https://github.com/dmwit/universe )
universe-reverse-instances : Instances of standard classes that are made possible by enumerations ( https://github.com/dmwit/universe )
unix-bytestring : Unix/Posix-specific functions for ByteStrings ( http://code.haskell.org/~wren/ )
unix-compat : Portable POSIX-compatibility layer ( https://github.com/haskell-pkg-janitors/unix-compat )
unix-memory : Unix memory syscalls ( https://github.com/vincenthz/hs-unix-memory )
unix-time : Unix time parser/formatter and utilities ( https://hackage.haskell.org/package/unix-time )
unixutils : A crude interface between Haskell and Unix-like operating systems ( https://github.com/seereason/haskell-unixutils.git )
unlambda : Unlambda interpreter ( https://hackage.haskell.org/package/unlambda )
unliftio : The MonadUnliftIO typeclass for unlifting monads to IO (batteries included) ( https://github.com/fpco/unliftio/tree/master/unliftio#readme )
unliftio-core : The MonadUnliftIO typeclass for unlifting monads to IO ( https://github.com/fpco/unliftio/tree/master/unliftio-core#readme )
unordered-containers : Efficient hashing-based container types ( https://github.com/haskell-unordered-containers/unordered-containers )
unsafe : Unified interface to unsafe functions ( https://code.haskell.org/~thielema/unsafe/ )
uri : Library for working with URIs ( https://hackage.haskell.org/package/uri )
uri-bytestring : Haskell URI parsing as ByteStrings ( https://github.com/Soostone/uri-bytestring )
uri-bytestring-aeson : Aeson instances for URI Bytestring ( https://github.com/reactormonk/uri-bytestring-aeson )
uri-encode : Unicode aware uri-encoding ( https://hackage.haskell.org/package/uri-encode )
url : A library for working with URLs ( https://www.haskell.org/haskellwiki/Url )
userid : The UserId type and useful instances for web development ( https://www.github.com/Happstack/userid )
users : A library simplifying user management for web applications ( https://github.com/agrafix/users )
utf8-light : Lightweight UTF8 handling ( https://hackage.haskell.org/package/utf8-light )
utf8-string : Support for reading and writing UTF8 Strings ( https://github.com/glguy/utf8-string/ )
utility-ht : Various small helper functions for Lists, Maybes, Tuples, Functions ( https://hackage.haskell.org/package/utility-ht )
utilitytm : Utility functions that are missing from the standard library ( https://github.com/tonymorris/utility-tm )
uu-interleaved : interleaving combinator for use with applicative/alternative style ( https://github.com/UU-ComputerScience/uu-interleaved )
uu-parsinglib : Online error-correcting monadic applicative and more parser combinators ( http://www.cs.uu.nl/wiki/bin/view/HUT/ParserCombinators )
uuagc : Attribute Grammar System of Universiteit Utrecht ( http://www.cs.uu.nl/wiki/HUT/WebHome )
uuagc-bootstrap : Attribute Grammar System of Universiteit Utrecht ( http://www.cs.uu.nl/wiki/HUT/WebHome )
uuagc-cabal : Cabal plugin for UUAGC ( https://github.com/UU-ComputerScience/uuagc )
uuid : For creating, comparing, parsing and printing Universally Unique Identifiers ( https://github.com/haskell-hvr/uuid )
uuid-orphans : Orphan instances for the UUID datatype ( https://hackage.haskell.org/package/uuid-orphans )
uuid-types : Type definitions for Universally Unique Identifiers ( https://github.com/haskell-hvr/uuid )
uulib : Haskell Utrecht Tools Library ( https://github.com/UU-ComputerScience/uulib )
validated-literals : Compile-time checking for partial smart-constructors ( https://github.com/merijn/validated-literals )
validation : A data-type like Either but with an accumulating Applicative ( https://github.com/qfpl/validation )
validation-selective : Lighweight pure data validation based on Applicative and Selective functors ( https://github.com/kowainik/validation-selective )
validity : Validity typeclass ( https://github.com/NorfairKing/validity#readme )
validity-aeson : Validity instances for aeson ( https://github.com/NorfairKing/validity#readme )
validity-containers : Validity instances for containers ( https://github.com/NorfairKing/validity#readme )
validity-path : Validity instances for Path ( https://github.com/NorfairKing/validity#readme )
validity-scientific : Validity instances for scientific ( https://github.com/NorfairKing/validity#readme )
validity-text : Validity instances for text ( https://github.com/NorfairKing/validity#readme )
validity-unordered-containers : Validity instances for unordered-containers ( https://github.com/NorfairKing/validity#readme )
validity-vector : Validity instances for vector ( https://github.com/NorfairKing/validity#readme )
varying : FRP through value streams and monadic splines ( https://github.com/schell/varying )
vault : a persistent store for values of arbitrary types ( https://github.com/HeinrichApfelmus/vault )
vcs-revision : Facilities for accessing the version control revision of the current directory ( https://hackage.haskell.org/package/vcs-revision )
vcswrapper : Wrapper for source code management systems ( https://github.com/forste/haskellVCSWrapper )
vect : A low-dimensional linear algebra library, tailored to computer graphics ( http://code.haskell.org/~bkomuves/ )
vector : Efficient Arrays ( https://github.com/haskell/vector )
vector-algorithms : Efficient algorithms for vector arrays ( https://github.com/erikd/vector-algorithms/ )
vector-binary-instances : Instances of Data.Binary for vector ( https://github.com/haskell/vector-binary-instances )
vector-builder : Vector builder ( https://github.com/nikita-volkov/vector-builder )
vector-hashtables : Efficient vector-based mutable hashtables implementation ( https://github.com/klapaucius/vector-hashtables#readme )
vector-instances : Orphan Instances for 'Data.Vector' ( https://github.com/ekmett/vector-instances )
vector-random : Generate vectors filled with high quality pseudorandom numbers ( http://code.haskell.org/~dons/code/vector-random )
vector-sized : Size tagged vectors ( https://github.com/expipiplus1/vector-sized#readme )
vector-space : Vector and affine spaces, linear maps, and derivatives ( https://hackage.haskell.org/package/vector-space )
vector-space-points : A type for points, as distinct from vectors ( https://hackage.haskell.org/package/vector-space-points )
vector-stream : Efficient Streams ( https://github.com/haskell/vector )
vector-th-unbox : Deriver for Data.Vector.Unboxed using Template Haskell ( https://github.com/tsurucapital/vector-th-unbox )
versions : Types and parsers for software version numbers ( https://github.com/fosskers/versions )
vinyl : Extensible Records ( https://hackage.haskell.org/package/vinyl )
vinyl-gl : Utilities for working with OpenGL's GLSL shading language and vinyl records ( https://hackage.haskell.org/package/vinyl-gl )
void : A Haskell 98 logically uninhabited data type ( https://github.com/ekmett/void )
vty-crossplatform : Cross-platform support for Vty ( https://hackage.haskell.org/package/vty-crossplatform )
vty-unix : Unix backend for Vty ( https://hackage.haskell.org/package/vty-unix )
wai-app-file-cgi : File/CGI/Rev Proxy App of WAI ( http://www.mew.org/~kazu/proj/mighttpd/ )
wai-app-static : WAI application for static serving ( http://www.yesodweb.com/book/web-application-interface )
wai-conduit : conduit wrappers for WAI ( https://github.com/yesodweb/wai )
wai-cors : CORS for WAI ( https://github.com/larskuhtz/wai-cors )
wai-eventsource : WAI support for server-sent events (deprecated) ( http://www.yesodweb.com/book/web-application-interface )
wai-extra : Provides some basic WAI handlers and middleware ( https://github.com/yesodweb/wai )
wai-handler-launch : Launch a web app in the default browser ( https://hackage.haskell.org/package/wai-handler-launch )
wai-http2-extra : WAI utilities for HTTP/2 ( https://github.com/yesodweb/wai )
wai-logger : A logging system for WAI ( https://hackage.haskell.org/package/wai-logger )
wai-test : Unit test framework (built on HUnit) for WAI applications. (deprecated) ( https://www.yesodweb.com/book/web-application-interface )
wai-websockets : Provide a bridge between WAI and the websockets package ( https://github.com/yesodweb/wai )
warp : A fast, light-weight web server for WAI applications ( https://github.com/yesodweb/wai )
warp-tls : HTTP over TLS support for Warp via the TLS package ( https://github.com/yesodweb/wai )
wavy : Process WAVE files in Haskell ( http://bitbucket.org/robertmassaioli/wavy )
wcwidth : Native wcwidth ( https://github.com/solidsnack/wcwidth/ )
web-encodings : Encapsulate multiple web encoding in a single package. (deprecated) ( https://hackage.haskell.org/package/web-encodings )
web-plugins : dynamic plugin system for web applications ( https://github.com/clckwrks/web-plugins )
web-routes : portable, type-safe URL routing ( https://www.happstack.com/docs/crashcourse/index.html#web-routes )
web-routes-boomerang : Use boomerang for type-safe URL parsers/printers ( https://hackage.haskell.org/package/web-routes-boomerang )
web-routes-happstack : Adds support for using web-routes with Happstack ( https://hackage.haskell.org/package/web-routes-happstack )
web-routes-hsp : Adds XMLGenerator instance for RouteT monad ( https://hackage.haskell.org/package/web-routes-hsp )
web-routes-th : Support for deriving PathInfo using Template Haskell ( https://github.com/happstack/web-routes-th )
webdriver : a Haskell client for the Selenium WebDriver protocol ( https://github.com/kallisti-dev/hs-webdriver )
websockets : A sensible and clean way to write WebSocket-capable servers in Haskell ( https://jaspervdj.be/websockets )
websockets-snap : Snap integration for the websockets library ( https://hackage.haskell.org/package/websockets-snap )
weeder : Detect dead code ( https://github.com/ndmitchell/weeder#readme )
weigh : Measure allocations of a Haskell functions/values ( https://github.com/fpco/weigh#readme )
which : Determine the full path to an executable ( https://hackage.haskell.org/package/which )
wide-word : Data types for large but fixed width signed and unsigned integers ( https://github.com/erikd/wide-word )
winery : Sustainable serialisation library ( https://github.com/fumieval/winery#readme )
wire-streams : Fast binary io-streams adapter ( https://github.com/winterland1989/wire-streams )
with-location : Use ImplicitParams-based source locations in a backward compatible way ( https://github.com/sol/with-location#readme )
with-utf8 : Get your IO right on the first try ( https://github.com/serokell/haskell-with-utf8#readme )
witherable : filterable traversable ( https://github.com/fumieval/witherable )
witherable-class : Witherable = Traversable + Filterable ( https://hackage.haskell.org/package/witherable-class )
wizards : High level, generic library for interrogative user interfaces ( https://hackage.haskell.org/package/wizards )
wl-pprint : The Wadler/Leijen Pretty Printer ( https://hackage.haskell.org/package/wl-pprint )
wl-pprint-annotated : Pretty printer with annotation support ( https://github.com/minad/wl-pprint-annotated#readme )
wl-pprint-text : A Wadler/Leijen Pretty Printer for Text values ( https://hackage.haskell.org/package/wl-pprint-text )
word-trie : Implementation of a finite trie over words ( https://github.com/yi-editor/word-trie )
word-wrap : A library for word-wrapping ( https://github.com/jtdaugherty/word-wrap/ )
word24 : 24-bit word and int types for GHC ( https://github.com/winterland1989/word24 )
wordexp : wordexp(3) wrappers ( https://hackage.haskell.org/package/wordexp )
workdays : Workday calculations ( https://github.com/stackbuilders/workdays )
wraparound : Convenient handling of points on a seamless 2-dimensional plane ( https://frigidcode.com )
wreq : An easy-to-use HTTP client library ( https://www.serpentine.com/wreq )
writer-cps-mtl : MonadWriter orphan instances for writer-cps-transformers ( https://github.com/minad/writer-cps-mtl#readme )
writer-cps-transformers : WriteT and RWST monad transformers ( https://github.com/minad/writer-cps-transformers#readme )
wuss : Secure WebSocket (WSS) clients ( https://hackage.haskell.org/package/wuss )
wx : A portable and native GUI library for Haskell built on top of wxWidgets ( https://wiki.haskell.org/WxHaskell )
wxc : wxHaskell C++ wrapper ( https://wiki.haskell.org/WxHaskell )
wxcore : wxHaskell core ( https://wiki.haskell.org/WxHaskell )
wxdirect : helper tool for building wxHaskell ( https://wiki.haskell.org/WxHaskell )
x11 : A binding to the X11 graphics library ( https://github.com/xmonad/X11 )
x11-xft : Bindings to the Xft and some Xrender parts ( https://hackage.haskell.org/package/X11-xft )
x509 : X509 reader and writer ( https://github.com/vincenthz/hs-certificate )
x509-store : X.509 collection accessing and storing methods ( https://github.com/vincenthz/hs-certificate )
x509-system : Handle per-operating-system X.509 accessors and storage ( https://github.com/vincenthz/hs-certificate )
x509-validation : X.509 Certificate and CRL validation ( https://github.com/vincenthz/hs-certificate )
xattr : Haskell extended file attributes interface ( https://hackage.haskell.org/package/xattr )
xcb-types : Parses XML files used by the XCB project ( https://community.haskell.org/~aslatter/code/xcb-types )
xdg-basedir : A basic implementation of the XDG Base Directory specification ( https://github.com/willdonnelly/xdg-basedir )
xdg-desktop-entry : Parse files conforming to the xdg desktop entry spec ( https://hackage.haskell.org/package/xdg-desktop-entry )
xdg-userdirs : Basic implementation of XDG user directories specification ( https://redmine.iportnov.ru/projects/xdg-userdirs )
xdot : Parse Graphviz xdot files and interactively view them using GTK and Cairo ( https://hackage.haskell.org/package/xdot )
xeno : A fast event-based XML parser in pure Haskell ( https://github.com/ocramz/xeno )
xformat : Extensible, type-safe formatting with scanf- and printf-like functions ( https://github.com/spl/xformat )
xhtml : An XHTML combinator library ( https://github.com/haskell/xhtml )
xhtml-combinators : Fast and easy to use XHTML combinators ( http://www.dcs.shef.ac.uk/~aca08aa/xhtmlc.html )
xlsx : Simple and incomplete Excel file parser/writer ( https://github.com/qrilka/xlsx )
xml-conduit : Pure-Haskell utilities for dealing with XML with the conduit package ( https://github.com/snoyberg/xml )
xml-hamlet : Hamlet-style quasiquoter for XML content ( https://www.yesodweb.com/ )
xml-helpers : Some useful helper functions for the xml library ( https://github.com/acw/xml-helpers )
xml-html-conduit-lens : Optics for xml-conduit and html-conduit ( https://github.com/supki/xml-html-conduit-lens#readme )
xml-html-qq : Quasi-quoters for XML and HTML Documents ( https://github.com/cdepillabout/xml-html-qq )
xml-lens : Lenses, traversals, and prisms for xml-conduit ( https://github.com/fumieval/xml-lens )
xml-picklers : XML picklers based on xml-types, ported from hexpat-pickle ( https://hackage.haskell.org/package/xml-picklers )
xml-types : Basic types for representing XML ( https://git.singpolyma.net/xml-types-haskell )
xmlgen : Fast XML generation library ( https://hackage.haskell.org/package/xmlgen )
xmlhtml : XML parser and renderer with HTML 5 quirks mode ( https://github.com/snapframework/xmlhtml )
xss-sanitize : sanitize untrusted HTML to prevent XSS attacks ( https://github.com/yesodweb/haskell-xss-sanitize#readme )
xxhash-ffi : Bindings to the C implementation the xxHash algorithm ( https://github.com/haskell-haskey/xxhash-ffi#readme )
yaml : Support for parsing and rendering YAML documents ( https://github.com/snoyberg/yaml#readme )
yaml-light : A light-weight wrapper with utility functions around HsSyck ( https://hackage.haskell.org/package/yaml-light )
yampa : Library for programming hybrid systems ( https://github.com/ivanperez-keera/Yampa/ )
yesod : Creation of type-safe, RESTful web applications ( https://www.yesodweb.com/ )
yesod-angular : Angular JS integratoin ( https://hackage.haskell.org/package/yesod-angular )
yesod-auth : Authentication for Yesod ( https://www.yesodweb.com/ )
yesod-auth-basic : Yesod Middleware for HTTP Basic Authentication ( https://hackage.haskell.org/package/yesod-auth-basic )
yesod-auth-hashdb : Authentication plugin for Yesod ( https://github.com/paul-rouse/yesod-auth-hashdb )
yesod-auth-oauth2 : OAuth 2.0 authentication plugins ( https://github.com/freckle/yesod-auth-oauth2 )
yesod-colonnade : Helper functions for using yesod with colonnade ( https://github.com/andrewthad/colonnade#readme )
yesod-content-pdf : PDF Content Type for Yesod ( https://github.com/alexkyllo/yesod-content-pdf#readme )
yesod-core : Creation of type-safe, RESTful web applications ( https://www.yesodweb.com/ )
yesod-default : Default config and main functions for your yesod application (deprecated) ( http://www.yesodweb.com/ )
yesod-elements : Non template haskell markup building function in the spirit of lucid ( https://hackage.haskell.org/package/yesod-elements )
yesod-eventsource : Server-sent events support for Yesod apps ( https://www.yesodweb.com/ )
yesod-form : Form handling support for Yesod Web Framework ( https://www.yesodweb.com/ )
yesod-gitrepo : Host content provided by a Git repo ( https://github.com/snoyberg/yesod-gitrepo#readme )
yesod-json : Generate content for Yesod using the aeson package. (deprecated) ( http://www.yesodweb.com/ )
yesod-markdown : Tools for using markdown in a yesod application ( https://github.com/pbrisbin/yesod-markdown )
yesod-newsfeed : Helper functions and data types for producing News feeds ( http://www.yesodweb.com/ )
yesod-paginator : A pagination approach for yesod ( https://github.com/pbrisbin/yesod-paginator )
yesod-persistent : Some helpers for using Persistent from Yesod ( https://www.yesodweb.com/ )
yesod-recaptcha2 : yesod recaptcha2 ( https://github.com/ncaq/yesod-recaptcha2#readme )
yesod-sitemap : Generate XML sitemaps ( http://www.yesodweb.com/ )
yesod-static : Static file serving subsite for Yesod Web Framework ( https://www.yesodweb.com/ )
yesod-table : HTML tables for Yesod ( https://github.com/andrewthad/yesod-table )
yesod-test : integration testing for WAI/Yesod Applications ( https://www.yesodweb.com )
yesod-websockets : WebSockets support for Yesod ( https://github.com/yesodweb/yesod )
yi-rope : A rope data structure used by Yi ( https://hackage.haskell.org/package/yi-rope )
zeromq4-haskell : Bindings to ZeroMQ 4.x ( https://gitlab.com/twittner/zeromq-haskell/ )
zigzag : Zigzag encoding of integers into unsigned integers ( https://github.com/byteverse/zigzag )
zip-archive : Library for creating and modifying zip archives ( https://github.com/jgm/zip-archive )
zippers : Traversal based zippers ( https://github.com/ekmett/zippers/ )
zlib : Compression and decompression in the gzip and zlib formats ( https://hackage.haskell.org/package/zlib )
zlib-bindings : Low-level bindings to the zlib package. (deprecated) ( https://github.com/snoyberg/zlib-bindings )
zlib-conduit : Streaming compression/decompression via conduits. (deprecated) ( https://github.com/snoyberg/conduit )
zlib-enum : Enumerator interface for zlib compression ( https://github.com/maltem/zlib-enum )
zmidi-core : Read and write MIDI files ( https://github.com/stephentetley/zmidi-core )
ztail : Multi-file, colored, filtered log tailer ( https://hackage.haskell.org/package/ztail )
zxcvbn-hs : Password strength estimation based on zxcvbn ( https://github.com/sthenauth/zxcvbn-hs )
Add an ebuild in portage :
The ebuild is now in the portage tree.
You can also use layman : emerge layman then layman -a haskell
For Paludis use this rsync : rsync://gentoo.zugaina.org/haskell-portage
If you have a problem : ycarus(-at-)zugaina.org