Not currently logged in. Login now.

Libraries for Category 'Utility'

Robert HookeRobert Hooke provides a flexible, composable mechanism by which you can extend behaviour of functions after they've been defined. It's named after Robert Hooke FRS, a founding member of the Royal Society who made many important discoveries in the fields of Gravitation, Microscopy, and Astronomy.
calxIdiomatic opencl bindings for clojure
clj-base64A very basic library of functions for encoding and decoding strings (sequences of characters) using the base64 coding scheme.
clansiANSI color and style codes for Clojure.
LaminaLamina provides an event-driven analogue to Clojure’s sequences, called channels. Similar mechanisms have been used in languages such as Go, JoCaml, and C#.
ConduitStream processing API
clojure-aopAOP in Clojure
dgraphA dependency graph library for Clojure
clj-etl-utilsETL Utilities for Clojure. These are mostly centered around functions that work with data on disk, such as database dumps and log files. At least that was the original purpose of the library, it has since grown to include other utilities.
TrammelContracts programming for Clojure.
Syntax-RulesA library for defining hygienic macros based on pattern matching. This library provides many features of syntax-parse from Racket and provides a syntax-rules-based interface and a syntax-case-based interface to its facilities.
clj-timeClojure binding for jodatime
workwork is a new generalized worker pool core for clojure.
clj-lfsrLinear Feedback Shift Register in Clojure.

Wikipedia describes LFSRs as:

A linear feedback shift register (LFSR) is a shift register whose input bit is a linear function of its previous state.

It describes their uses as:

Applications of LFSRs include generating pseudo-random numbers, pseudo-noise sequences, fast digital counters, and whitening sequences.
clj-bloomBloom Filter implementation in Clojure.

A bloom filter is a probabilistic data structure for testing set membership.
hot-potatoFunction-wrappers that change the order of supplied parameters, built on top of a generic permutation function that you can extend if you want to permute functions in a different way.
((reorder map) [1 2] inc) => (2 3)
(apply (reorder {0 3} str) '[Cat in the Hat]) => "HatintheCat"
cljsAn experimental Clojure(ish) to Javascript compiler.

SpineA high-level, Beanstalkd-backed job queueing library for Clojure.
Clj-MiscUtilClj-MiscUtil is an assortment of Clojure functions/macros to carry out miscellaneous common activities.
CloherenceClojure abstraction with map semantic and DSL on top of Coherence.
vijualVijual is a graph layout engine conceptually similar to graphviz. However, it uses different layout algorithms, creating graphs with a different aesthetic. Vijual uses specialized algorithms for optimal rendering of trees, binary trees, directed, and undirected graphs. Also, it has robust abilities for generating attractive ASCII graphs (as well as traditional bitmap graphs) making it well suited for debugging and exploratory programming directly from the Clojure REPL.
MatchureMatchure is pattern matching for clojure.

* sequence destructuring
* map destructuring
* equality checks
* regexp matches
* variable binding
* instance checking
* arbitrary boolean expressions
* boolean operators (and, or, not)
* if, when, cond, fn, and defn variants
justlogitMinimal logging library for Clojure.
classlojureclasslojure lets you easily create a classloader with an alternate classpath and evaluate clojure forms in it. This classloader can even use a different version of clojure than your primary classloader.
thread-exprA library containing macros for use in clojure threading expressions (using ->).
SlamhoundSlamhound rips your namespace form apart and reconstructs it. In other words - it fixes your namespace declarations. Used from leiningen or through clojure-swank.
clj-rippleThis is a library for translating Clojure source code to Ripple source code (for navigating the Semantic Web) to make it easier to embed Ripple in a Clojure program
Robert BruceRobert Bruce provides an easy way to execute a function and allow failures to be automatically retried. It's named after Robert the Bruce, whose determination was inspired by the sight a spider trying (and failing) many times to build a web.
forsetiforseti is a library for lightweight Aspect-Oriented Programming in Clojure.
fenrirAn alternative class-based object-system for Clojure based on hash-maps and multimethods.
unkA pluggable, manipulable memoization framework for Clojure.
heimdallrheimdallr is a library for Context-Oriented Programming in Clojure.
clj-sshSSH in clojure. Uses jsch. Provides a ssh function that tries to look similar to
SanitySanity is a clojure library which uses plug-in based macros to…

1. deduce argument types based on argument names
2. add type hints & assertions based on the former

Furthermore, the plug-in system can be used to enhance any macro you like in various ways.
BoingBoing is a Java dependency injection tool written in Clojure. The main motivation behind this initiative was to get away from Spring beans and many of the dependencies that it carries in our software. Hence the name... if you have better suggestions, let us know.
ScripturianScripturian is an open source library that makes it easy to integrate various programming and templating languages into your JVM-based software. It is designed from the ground-up for high performance concurrent execution, and as such offers a scalable alternative to the Java scripting standard (JSR-223).

Includes Clojure support
slingshotEnhanced throw and catch for Clojure

Provides try+ and throw+. Each is 100% compatible with Clojure and Java’s native try and throw both in source code and at runtime. Each also provides new capabilities intended to improve ease of use by leveraging Clojure’s capabilities like records and destructuring.
closerlThis library is a bridge between Clojure and Erlang using the library JInterface.
clj-pingbackAn implementation of the Pingback API for clojure.
indexed-setA set implementation which can

* maintain summaries (eg indexes),
* enforce unicity of items in regards to custom keys (fns),
* support primary key.
quartz-cljclojure utils/tools for starting/manipulating quartz tasks
pomegranatePomegranate is a library that provides:

A wrapper for Sonatype Aether.

A re-implementation of add-classpath (deprecated in Clojure core) that:

* is a little more comprehensive than core’s add-classpath — it should work as expected in more circumstances, and
* optionally uses Aether to add a Maven artifact (and all of its transitive dependencies) to your Clojure runtime’s classpath dynamically.
FidjetFidjet is dead-simple ad-hoc configuration for pure functions. If you write a core API where functions accept some config parameter as their first argument, you can then create a parallel namespace where those same functions can be used in a with-config block.
clj-disruptorclojure wrapper for the LMax Disruptor.

references :

cljs-uuidSimple CLJS uuid generator

* can generate version4 (random uuid), as per
* can read and print uuid literals as per (but no cljs reader capability)
* can read and print plain uuid strings '8-4-4-4-12'
cljextClojure Extended Library

cljext is a library containing clojure native code and wrappers of Java functions. This provides extra functionality to pad out the clojure standard library.
Clojure-completeClojure-complete is an symbol completion library for Clojure.
clj-rpeClj-rpe is a Clojure library that implements Regular Path Expressions (RPEs) on Clojure data structures and arbitrary Java objects. It enables you to retrieve the ordered set of objects reachable from a given start object (or set of start objects) by traversing a path conforming to a regular path description.

A regular path description is a declarative means to specify allowed paths in some object structure in terms of keys in a map or fields/methods in classes. Those can be composed using regular operators such as sequence, option, alternative, and iterations.
frinjFrinj is a practical unit-of-measure calculator DSL for Clojure.

Key features;

* Tracks units of measure through all calculations allowing you to mix units of measure transparently
* Comes with a huge database of units and conversion factors
* Inspired by the Frink project (
* Tries to combine Frink's fluent calculation style with idiomatic Clojure
riverA monadic stream library in Clojure (port of Haskell's enumerator). river tries to provide an implementation of Oleg's Iteratee library.
clojure-contrib-1.3-compatThis is Clojure Contrib, 1.2.0, patched to compile against Clojure 1.3.

It is generally better to use the newer Clojure contrib libraries however if you don't have the time to do this then this represents a reasonable alternative.
clojure-optionsThis library provides improved handling for Clojure functions with optional parameters. The library provides the macro defn+opts which defines a function with optional parameters. The syntax is similar to the one of Clojure's defn except that only one function body is allowed.

A documentation string for optional parameters is supported. When a defn+opts function f calls another defn+opts function g and passes its options symbol then the docstring of f will contain information about the optional parameters that can be passed to g.
let-elseThe let? macro has the same behavior as let, except where a binding is followed by one or more of keyword clauses.

A contrived example:

(when-let [a foo]
(let [b bar]
(when (even? b)
(let [c baz]
(when (> b c)
(let [d qux]
(f a b c d)))))))


(let? [a foo :else nil
b bar :is even?
c baz :when (> b c)
d qux]
(f a b c d))
evaljsEvaljs is a library for evaluating Javascript code in Clojure.
DecorateDecorates regular functions to add extra functionality
clojure-contractsClojure-contracts is a library for contract programming in Clojure.
mississippiValidates that a map confirms to a particular structure.
ShadyJava interop utility functions & macros.
guzhengguzheng is a library for instrumenting clojure code.
romulanClojureWerkz Romulan is a Clojure DSL for LMAX Disruptor.
syntactic-closuresyntactic-closure is a Clojure library that provides some facilities to define hygienic macros with syntactic closures. It aims to implement a hygienic macro system interoperable with Clojure's macro system.
MoneyClojureWerkz Money is a Clojure library that deals with monetary values
elastischElastisch is a Clojure client for ElasticSearch, a modern distributed RESTful search engine.
timingTiming is a simple library to log call time using perf4j.
carboniteEver needed to freeze your Clojure data in perfect hibernation? Ever want to deserialize your data without concealing yourself as a bounty hunter in Jabba's desert palace?

Carbonite is a Clojure library to convert Clojure data to serialized form and back using the Kryo serialization library. Kryo is known for being fast and producing very small serializations.
clj-wallhackA library for bypassing private & protect fields & methods on java classes. Extracted from old contrib. Derived from work by hiredman.
milieuThe environmentally friendly configuration tool.
clj-jsr223clj-jsr223 is a JSR 223 implementation written in Clojure. The JSR 223 specification describes mechanisms allowing scripting language programs to access information developed in the Java Platform and allowing scripting language pages to be used in Java Server-side Applications.
subversion-cljSimple SVNKit based Subversion API for Clojure
clj-jgitClojure wrapper for using the JGit library to manipulate Git repositories in a "pure Java" fashion.
orderedordered provides sets and maps that maintain the insertion order of their contents.
data.priority-mapA priority map is very similar to a sorted map, but whereas a sorted map produces a sequence of the entries sorted by key, a priority map produces the entries sorted by value.

In addition to supporting all the functions a sorted map supports, a priority map can also be thought of as a queue of [item priority] pairs. To support usage as a versatile priority queue, priority maps also support conj/peek/pop operations.
polyfnOpen, single dispatch polymorphism. A simple fast alternative to defmulti.
sigmundSigmund is friendly clojure wrapper around the Hyperic SIGAR API It can tell you all sorts of information about your currently executing process as well as the system that you are working on. It provides quite a bit more information than JMX:

os: information, processes, memory, swap, resource limits, uptime and logins.
cpu: information, per cpu and average usage.
jvm: runtime information for jvm.
filesystem: mounted devices, disk usage, filesystem properties and usage.
network: usage, bandwidth, gateways, interface, routes and connection status.
process: per process information for cpu, memory, environment, credentials, arguments and other information.
neuroticA library to get traits support to clojure's deftype, defrecord and extend.

The purpose of this library is to provide a mechanism of code-reuse for those occasions when using a map and extend is not fast enough, or, in the case of java interfaces instead of clojure protcols, extend would simply be impossible to use.
strucjurePattern-matching, parsing and generic traversals through the medium of PEGs.
dynapathdynapath provides a protocol and util functions for class loaders that make their effective classpaths readable and/or modifiable.
core.matchAn optimized pattern match and predicate dispatch library for Clojure. Currently the library only implements pattern matching. It supports Clojure 1.2.0 and later as well as ClojureScript.
MinderbinderConverting one thing into another via Clojure.
core.contractsContracts programming for Clojure.

Based on Trammel and clojure-contracts.
flowFunction definitions derived from graph declarations. Declare your inputs and outputs and flow figured out the rest.
bouncerA tiny Clojure library for validating maps (or records).
fippFipp is a better pretty printer for Clojure. It uses the fastest known pretty-printing algorithm and is powered by data instead of an API.
clj-schemaSchemas for Clojure Data Structures and Values
samplingThis library supports three flavors of random sampling: simple sampling, reservoir sampling, and stream sampling.
MorphHaskell-style plumbing for error-handling, sequenced execution with short-circuit on error, modeling of global data from pure functions, and their combinations thereof. Helps to write larger parts of programs with pure functions and less boilerplate.

Features include: curried functions, monoids, functors, monads, and monad transformers. Comes with a user guide, Codox API reference, and sample code.
plumbingPrismatic's Clojure utility belt
direDecomplect error logic. Error handling, pre/post conditions and general hooks for Clojure functions.
data.union-findA Clojure implementation of persistent disjoint-set forests using Tarjan's union-find algorithm.
synthreadExtensions of Clojure's standard -> macro used to build code blocks that operate on a threaded topic.
core.rrb-vectorAn implementation of the confluently persistent vector data structure introduced in Bagwell, Rompf, "RRB-Trees: Efficient Immutable Vectors", EPFL-REPORT-169879, September, 2011.

RRB-Trees build upon Clojure's PersistentVectors, adding logarithmic time concatenation and slicing.
VertigoVertigo allows you to treat raw bytes like a normal Clojure data structure. This allows for faster reads and reduced memory footprint, and can also make interop with C libraries significantly simpler and more efficient. With certain safety checks turned off, this yields performance a bit faster than Java arrays on a much wider variety of datatypes
fluokittenFluokitten is a Clojure library that implements category theory concepts, such as functors, applicative functors, monads, monoids etc. in idiomatic Clojure.
beckonA Clojure library to handle POSIX signals in JVM applications with style and grace. Sets up with the dirty parts and let you work with it in a (relatively) simple fashion.
clj-iterThis is clj-iter, an iteration macro for Clojure inspired by the excellent iterate library for Common Lisp.
cl-loopCommon lisp like loop macro.
ribolribol is a conditional restart library for clojure inspired by errorkit, having a more readable syntax, and designed with the base clojure.lang.ExceptionInfo type in mind.
GeminiA Clojure library designed to make easy the data matching.

The data matching is a way to find 2 data are the same even if there're some differences. For example, when you compare two names like "SMITH" and "SMIHT", in some cases you can say the second name is the same as the first one with a keyboard input error.
clj-tupleOften the lists we create have only a few elements in them. This library provides a collection type, tuple, which is optimized for these cases.

A tuple behaves exactly like a Clojure vector. However, compared lists and vectors, a two element tuple is ~2-3x faster to create, destructure, calculate a hash, check for equality, and look up in a normal Java hash-map. Some of these gains are amplified at larger sizes; a five element tuple is ~30x faster to create than a vector. Tuples larger than six elements, however, simply turn into standard vectors.
String Handling
pretzelclojure predicate functions - strings and combinations
inflections-cljClojure Inflection Library

Rails-like inflections for Clojure.
doricDoric is a library for rendering pretty emacs-style tables from Clojure data. Data is passed into Doric as nested collections, and comes out as a string suitable for printing.
re-randre-rand is a Clojure library for generating random strings from regular expressions.
stencilA fast, compliant implementation of Mustache in Clojure.

Stencil is a complete implementation of the Mustache spec, including the optional lambdas.

Mustache is a logic-less templating system.
dejourDejour provides an easy, works out of the box experience for the Clojure programming language.
clj-helpSimple help macro to regroup contrib functions useful for interactive development.
hexdumpA couple of functions for displaying numerical data as a hex dump (a la xxd).
TaskTask is a Clojure library for managing long-running tasks at the REPL. It was created because of the author's frustration with the lack of good ways to handle Java threads while doing computational experiments in Clojure.
Logic Programming
core.unifycore.unify is a Clojure contrib library providing the following features:

* Factory functions for constructing unification binding, subst, and unification functions, with or without occurs checking
* Packaged functions for unification binding, subst, and unification functions, with or without occurs checking, recognizing variables tagged as symbols prefixed with ? characters

core.unify is based on a library named Unifycle, found at that has been deprecated.
MímirMímir is an experimental rule engine written in Clojure. Mímir aims to implement a Rete network as a base.
clj-nativeClojure library wrapping JNA's direct call mapping
clj-logging-configThis library supports easy configuration of log frameworks (log4j, java.util.logging) via Clojure rather than Java properties files and XML.
timbreLogging with Java can be maddeningly, unnecessarily hard. Particularly if all you want is something simple that works out the box.

tools.logging helps, but it doesn't save you from the mess of logger dependencies and configuration hell.

Timbre is an attempt to make simple logging simple and more complex logging possible.
tools.loggingLogging macros which delegate to a specific logging implementation. At runtime a specific implementation is selected from, in order, slf4j, Apache commons-logging, log4j, and finally java.util.logging.