Awesome Level

An open list of awesome Level modules and resources. Add yours!

Click to expand

- [Bundles](#bundles) - [Core](#core) - [Stores](#stores) - [Layers](#layers) - [Encodings](#encodings) - [Sublevels](#sublevels) - [Processing](#processing) - [Databases](#databases) - [Shared Access](#shared-access) - [Streams](#streams) - [Iterators](#iterators) - [Hooks](#hooks) - [Range Options](#range-options) - [Data Structures](#data-structures) - [Transience](#transience) - [Atomicity](#atomicity) - [Jobs](#jobs) - [File System](#file-system) - [Utilities](#utilities) - [Replication](#replication) - [Tools](#tools) - [Benchmarking & Debugging](#benchmarking--debugging) - [Resources](#resources) - [Applications](#applications) - [Legacy](#legacy) - [Contributing](#contributing) - [License](#license)

Bundles

Convenience modules that bundle a store with levelup and encoding-down.

`level`

Bundle for leveldown and level-js. Main entry point for beginners.

`level-mem`

Bundle for memdown.

`level-rocksdb`

Bundle for rocksdb.

`level-hyper`

Bundle for leveldown-hyper.

`level-indexed`

Bundle for indexeddown. Alternative to level.

Core

`levelup`

The glue that holds everything together. Use this when you need a custom or swappable store.

`abstract-leveldown`

An abstract prototype matching the leveldown API. Use this to implement your own store.

`level-packager`

Package helper to export a bundle. Use this to create a new level-* bundle.

Stores

Modules that implement abstract-leveldown as storage for levelup.

`leveldown`

Backed by LevelDB.

`memdown`

Backed by in-memory RBTree.

`level-js`

Backed by IndexedDB.

`rocksdb`

Backed by RocksDB.

`leveldown-hyper`

Backed by HyperLevelDB.

`medeadown`

Backed by medea.

`jsondown`

Backed by JSON on disk

`asyncstorage-down`

Backed by AsyncStorage (React Native).

`mongodown`

Backed by MongoDB.

`sqldown`

Backed by sqlite3, pg, mysql or WebSQL.

`dynamo-down`

Backed by AWS DynamoDB.

`azureleveldown`

Backed by Windows Azure Table Storage.

`fruitdown`

Backed by IndexedDB (Apple).

`localstorage-down`

Backed by localStorage.

`riakdown`

Backed by riakpbc.

`mysqldown`

Backed by MySQL.

`redisdown`

Backed by Redis.

`leveldown-basho`

Backed by Basho's LevelDB fork.

`sheet-down`

Backed by Google Sheets.

`indexeddown`

Backed by IndexedDB.

`lmdb-leveldown`

Backed by LMDB.

`localdown`

Backed by localStorage in Node.js.

`aerospike-leveldown`

Backed by Aerospike.

`s3leveldown`

Backed by AWS S3.

`gaiadown-ts`

Backed by Gaia.

`dynamodb-leveldown`

Backed by AWS DynamoDB.

`localforagedown`

Backed by localForage.

`react-native-leveldown`

Backed by LevelDB (React Native).

`networked-hyperbeedown`

Backed by Hyperbee.

Layers

Modules that implement abstract-leveldown to wrap another abstract-leveldown. This is the preferred extension point.

`encoding-down`

Provides key/value encoding.

`@adorsys/encrypt-down`

Provides encryption for values.

`deferred-leveldown`

Handles delayed-open. Built into levelup.

`level-cowdown`

Copy-on-write abstract-leveldown layer.

`abstract-stream-leveldown`

A stream-based abstract prototype.

Encodings

Custom level-codec compatible encodings for use with encoding-down.

`charwise`

Encode/decode with same encoded sort order as bytewise.

`bytewise`

Binary serialization which sorts bytewise for arbitrarily complex data structures. NB. Use charwise if possible. Gives you almost everything bytewise does but much faster.

`protocol-buffers`

Protocol Buffers for Node.js. Compiled messages are level-codec compatible encodings.

`lexicographic-integer-encoding`

Wraps lexicographic-integer.

Sublevels

Modules related to splitting a database into sections a.k.a. sublevels.

`subleveldown`

Split a levelup database into sublevels with their own keyspace, encoding and events.

`level-temp`

Create a temporary subleveldown sublevel that is guaranteed to be empty.

`level-mount`

Mount multiple abstract-leveldown stores by key prefix onto a single store. Can be used with subleveldown.

`bytespace`

Keypath subspaces prefixed with bytewise tuples. Similar to level-sublevel. NB. bytewise - and thus bytespace - can be slow. Consider using subleveldown paired with the charwise encoding instead.

`level-sublevel`

Adds the ability to create subsections with the same API as levelup, but only write/read to a prefixed section, or bucket, of the key-space. Each section also has level-hooks installed. NB. No longer maintained. We recommend subleveldown instead.

`sublevel-prefixer`

Utility to prefix a key with a sublevel prefix.

`level-sublevel-stream`

Find level-sublevel sublevels, not requiring them to be in memory already.

`level-subtree`

Generate a tree from level-sublevel sublevels, useful when there is no manifest.

`level-superlevel`

Superlevel adds a "super" level that allows accessing the entire database, discovering level-sublevel sublevels and browsing the database without knowledge of the sublevel structure.

`level-subkey`

Use path-like keys to separate sections of levelup, with hooks. Adapted from level-sublevel.

`level-mirror`

Mirror and optionally transform data from one level-sublevel sublevel into another.

Processing

Modules for indexing, alternative forms of querying data, MapReduce models and other forms of data processing.

`level-auto-index`

Automatic secondary indexing for levelup and subleveldown.

`jsonquery`

Query levelup with a MongoDB-like query API that returns streams.

`jsonquery-engine`

A full MongoDB query language implementation with indexes for querying levelup.

`level-indico`

Yet another indexing plugin for levelup. By providing only a low-level querying mechanism it gives you the power to build more complicated and optimized queries on top of it.

NB. Relies on bytewise and level-sublevel, both of which have caveats.

`level-inverted-index`

Create an inverted index for full-text search.

`map-reduce`

A MapReduce implementation on top of levelup. Allows you to define a map reduce query that will run on top of your db. The map reduces are incremental, and you can query the results in real-time.

`level-map-merge`

Like map-reduce but simpler. Has a batch component that runs periodically, and a real-time component that fills in the gaps. Good for generating inverted indexes.

`level-queryengine`

A generic pluggable query-engine system (that supports indexes) for levelup.

`level-trigger`

Triggers for levelup. Runs an async job when a key changes. All jobs will eventually run, even across restarts!

`levels`

A light-weight full text search engine for levelup (Port of TJ's reds redis search engine).

`map-reduce-chained`

Extends map-reduce and level-mapped-index to provide easy to setup chained MapReduce. An example use case is to find the top 10 values after a reduce.

`path-engine`

Query levelup using a JavaScript property path array syntax with indexes.

`subindex`

Generic pluggable indexing system for levelup.

`level-sec`

High-level API for creating secondary indexes.

`level-secondary`

Create and query secondary indexes.

`inverted-index`

Inverted index built upon levelup.

`level-index-update`

Remove the old indexes in the same batch as the new ones are inserted.

`range-index`

Range indexes for levelup.

`level-path-index`

Index properties of items that live in a tree of materialized paths.

`level-sql`

SQL queries for levelup.

`level-hash-index`

Store any string into levelup, and get a collision free hash of that value that you can use in an index (or similar).

`level-idx`

Another high-level API for creating secondary indexes, using level-auto-index.

`level-indexer`

Generic indexer for levelup. Only stores document keys for space efficiency.

`level-librarian`

Lightweight indexing and querying with the LLCJ query language.

`level-match-index`

Index and filter level-sublevel databases and watch for future changes.

`level-assoc`

Relational foreign key associations (hasMany, belongsTo) for levelup.

`level-tree-index`

Tree indexer for levelup.

`changes-index`

Create indexes from a changes-feed. Provides a way to create a materialized view on top of an append-only log.

`changesdown`

levelup interface that uses an abstract-leveldown store that writes to a changes-feed to store its state.

`level-ordered`

A wrapper for level that keeps inserted items ordered.

Databases

Complete Node.js databases built with Level.

`dat`

Lets you build streaming data pipelines that can be shared and replicated by others.

`pouchdb`

PouchDB allows you to store and query data offline and then sync with CouchDB when online. For Node, browser and mobile.

`couchup`

A CouchDB implementation on top of levelup.

`firedup`

A node.js implementation of firebase based on levelup.

`len`

Len is a resource booking database using LevelDB for storage. Useful for calendar and gantt chart apps and for questions like 'can a customer book this resource starting X and ending Y'.

`lem`

Lem is a telemetry storage database using LevelDB. Keys are indexed by timestamp and you can read values in-between 2 points in time.

`levelgraph`

A Graph database built on top of levelup with pattern-matching and join support.

`linvodb3`

Persistent database on top of levelup for Node.js/NW.js with MongoDB-style queries, Mongoose-like models and a map/reduce system.

`rxdb`

Event-driven database based on pouchdb. Optimized for reactive programming with observables. Events and state is automatically shared between multiple browser tabs. Queries are defined by the mongoDB mango-standard.

`pushdb`

A programmable database with document storage and unique indexing capabilities.

`search-index`

A persistent full text search engine for browser and Node.js.

`tacodb`

A responsive, Node.js-style database ideal for realtime data. Highly modular and adaptable, allowing extension with the Level ecosystem.

`timestreamdb`

A full-featured timeseries database on top of LevelDB. Includes a library for streaming statistical operations on timeseries data including joins, aggregates, filters, and map-like operations.

`@nano-sql/core`

A small (10Kb) RDBMS abstraction on top of levelup that also runs in the browser with undo/redo support, immutable objects and IndexedDB persistence.

`vertical`

LevelDB distributed, Server and Client!

`flash-store`

FlashStore is a Key-Value persistent storage with easy to use ES6 Map-like API(both Async and Sync support), powered by LevelDB and TypeScript.

`level-fact-base`

Store immutable facts and query them with datalog.

`dulcimer`

Define JSON models and manage indexes, children, foreign keys and much more.

`levi`

Stream based full-text search for Node.js and browser using levelup.

`level-mongo`

MongoDB-like database backed by LevelDB.

`level-orm`

Simple ORM built on levelup.

`level-lively`

levelup implementation of LivelyDb for doing real-time data binding of a database with local javascript objects.

`kwdb`

REST wrapper for levelup.

`level-restful`

REST wrapper for levelup, as an extension to level-orm.

`level-rest`

REST wrapper for levelup. NB. Not compatible with latest levelup.

Shared Access

`multileveldown`

Share a levelup instance across multiple processes or over the network. An alternative to multilevel, implemented as abstract-leveldown stores with seamless retry support.

`level-party`

Open a LevelDB (leveldown) handle multiple times, transparently upgrading to multileveldown when more than 1 process try to use the same LevelDB data directory at once and re-electing a new master when the primary unix socket (or named pipe) goes down.

`cluster-levelup`

Wrap a levelup instance for cluster usage among multiple processes.

`multilevel`

Share a levelup instance over the network.

`multilevel-http`

Expose a levelup instance via HTTP.

`level-range-emitter`

Client and server using multileveldown, range-emitter and ltgt.

`level-manifest`

Describe the functions that multilevel should provide access to on the client.

`level-cluster-get`

Given a key, get all values from a cluster of multilevel servers.

`level-connect`

Connect to a level-party and level-sublevel enabled LevelDB over HTTP.

`level-sandbox`

A sandbox for hosting multilevel enabled databases.

`level2riak`

A network service that allows you to connect to a Riak database over HTTP.

`leveldb-mount`

LevelDB server and client with optional client-side REPL. Built with subleveldown and multileveldown.

`level-pubsub`

PubSub with server and client on top of levelup.

`level-query`

Expose a level-sublevel database over HTTP, searchable with query strings.

`level-over-http`

Another solution to expose levelup over HTTP.

`level-rpc`

Fast RPC mechanism for levelup. Intended as binary-compatible alternative to multilevel.

Streams

Node.js stream or pull-stream implementations for reading and writing data from/to levelup.

`level-ws`

General-case, streams3 writable stream for levelup.

`level-batch-stream`

Streams2 writable stream for levelup.

`level-writestream`

Streams2 writable stream for levelup.

`level-write-stream`

Streams1 writable stream for levelup or abstract-leveldown.

`pull-level`

pull-stream interface to levelup with read streams, write streams and realtime (tail/live) reads.

`level-live-stream`

Like db.createReadStream() except it's live / tailable. i.e. instead of ending, it will stay open and stream changes to the database as they are inserted.

`level-live`

Simple, light and correct live read stream implementation. NB. Uses an undefined streams version.

`level-livefeed`

A live query of a range in levelup. Similar to level-live-stream but with a streams2 interface.

`level-range`

Find all K/V-pairs prefixed by a certain key. Streams1.

`level-cursor`

A stream "cursor" to iterate through a ReadStream / KeyStream / ValueStream.

`level-glob`

A streams2 read stream filtered and ordered by glob patterns. Keys in the database should be unix-like paths.

Iterators

Modules that operate on abstract-leveldown iterators.

`level-concat-iterator`

Concatenate items from an iterator into an array.

`level-iterator-stream`

Turn an abstract-leveldown iterator into a readable stream. Included in levelup.

`levelup-async-iterator`

Add an iterator() method to levelup with Symbol.asyncIterator. NB. Conflicts with iterator() added in levelup@3.1.0.

`level-iterator`

Decoding iterator for levelup instances. Wraps iterators like level-iterator-stream does. NB. Not compatible with levelup >= 2 due to encodings having moved out to encoding-down. PR welcome.

Hooks

Low-level utilities for hooking into a levelup instance.

`level-events`

Get an event everytime something is written / read / deleted using levelup.

`level-hookdown`

Simple levelup hooks.

`level-post`

Consistent post hooks for levelup.

`level-condition`

Get notified when a condition is triggered inside a levelup instance.

`level-hooks`

Implements a hook mechanism that allows you to intercept put, delete and batch operations. You can then turn those operations into batches. Useful if you want to turn a put into an atomic batch for say an automatic map operation.

NB. Author recommends using level-sublevel instead of level-hooks directly. Note that level-sublevel is not maintained.

Range Options

Utilities for working with range options, known as ltgt(e), common to levelup streams and abstract-leveldown iterators.

`ltgt`

Tool belt to find lower or upper bounds, compare and filter keys and more.

`level-option-wrap`

Wrap ltgt options with functions. Expose range options without leaking information about your internal key representations.

`interval-to-ltgt`

Convert an interval string to an ltgt object. This is the counterpart to ltgt-to-interval.

`ltgt-to-interval`

Convert an ltgt object to an interval string. This is the counterpart to interval-to-ltgt.

`range-emitter`

Range emitter. Publish keys and subscribe to ranges.

Data Structures

Modules that utilize a specific key/value scheme to provide a higher-level data structure.

`merkle-dag`

Merkle DAG on top of LevelDB

`merkle-patricia-tree`

Implementation of the modified merkle patricia tree as specified in Ethereum's yellow paper.

`level-array`

The array datatype inside levelup.

`level-set`

Add a set method to levelup for saving objects in a tree-like structure.

`level-push`

Add a push method to levelup for saving objects using level-set with auto-generated UUID.

`level-version`

Store and retrieve versioned data in levelup.

`level-queue-type`

The queue datatype inside levelup.

`level-q`

Priority queuing for levelup.

`qool`

A queue backed by levelup, durable and FIFO.

`level-trie`

The TRIE data structure and search algorithm, on top of levelup.

`level-geospatial`

Store key values pairs with lat/lon coordinates, and query using a radius.

`level-pathwise`

Turn levelup into one huge object of arbitrary size! Efficiently and atomically update and read parts of it.

`level-places`

Store and retrieve places near a lat/long pair.

`level-nearby-stream`

Stream in nearby places using the browser's geolocation and level-places.

`level-tree`

Geospatial indexing for GeoJSON in levelup

`level-list`

Map lists of data stored in levelup to DOM elements.

`level-reactive`

Reactive templating for data stored in levelup.

`level-paginate`

Streaming pagination for levelup.

`level-average`

Calculate rolling averages in levelup.

`level-sum`

Calculate sums in levelup and get live updates.

`level-historical-json`

Keep a history of all the changes of a JSON document.

`level-immutable`

levelup immutable history and database snapshotting based on ideas in datomic.

`level-model`

A higher-level module for creating content models using levelup and JSON Schema validation.

`level-stream`

Persist streams in levelup.

`level-stay`

An alternative approach to storing scuttlebutts in levelup.

`skeyma`

Turns a template string (like ${forumId}/${postId}) into parse/serialize streams that transform objects like {forumId, postId, text} into key-value pairs and back.

`level-autotable`

Auto incrementing keys with "fields" and "records".

`level-forks`

Forking graph of cascading namespaces.

`level-geo`

A geospatial index for levelup.

`level-geography`

Indexed geography storage in levelup.

`accountdown`

Persistent user accounts.

`accountdown-model`

A wrapper around accountdown that provides a few additional features

Transience

`cachedown`

LRU cache implemented as an abstract-leveldown layer.

`level-ttl`

Add a ttl (time-to-live) option to levelup. NB. Suffers from race issues. See also tiny-level-ttl.

`tiny-level-ttl`

Add a ttl (time-to-live) option to levelup, level-sublevel or level-spaces. Also respects level-lock.

`level-live-cache`

An in-memory cache that keeps up to date with its source.

`level-lru-cache`

Simple LRU cache.

`level-ttl-cache`

A pass-through cache for arbitrary objects or binary data using LevelDB, expired by a TTL.

`level-cache`

A caching module you can place in front of a levelup database. It will cache a subset of the database in an in-memory LRU cache based on configuration. It has an optional synchronous API which will return from the cache only.

`levelup-cache`

Use levelup to cache remote data.

Atomicity

`level-lock`

In-memory advisory read/write locks for levelup keys.

`level-mutex`

Mutex read/write lock for levelup.

`level-updater`

Update keys without overlapping changes - makes it possible to implement an atomic incrementer, JSON merger, etc.

`levelplus`

Adds atomic updates, increments, array pushes, set additions and user-defined atomic operations to levelup.

`level-atomics`

Add (parallel) atomic operations like insert, replace, increment and decrement to levelup.

`level-transactions`

Transaction layer for levelup.

Jobs

`level-schedule`

A durable job scheduler.

`level-jobs`

Job Queue in levelup.

`batchdb`

levelup and disk storage for queued batch jobs.

File System

`level-filesystem`

Full implementation of the Node.js fs module on top of levelup.

`browserify-fs`

level-filesystem as drop-in fs replacement for the browser, to be used with browserify.

`level-fs`

Node's fs module with levelup as backend.

`level-fs-browser`

level-fs as drop-in fs replacement for the browser, to be used with browserify.

`level-store`

A streaming storage engine based on levelup.

`level-serve`

Streaming static file server based on levelup.

`suckit`

Expose a level-store over HTTP.

`level-vinyl`

Vinyl adapter and blob store. Saves file contents in a content addressable blob store, file metadata in levelup.

`level-blob`

Store blobs in levelup

`level-blob-store`

An abstract-blob-store using LevelDB as the storage backend

`level-pull-blob-store`

A pull-blob-store implementation backed by LevelDB.

`level-server`

Standalone LevelDB file server based on level-serve, multilevel and level-sublevel.

Utilities

`level-codec`

Encode keys, values and ltgte options. Used in encoding-down.

`level-errors`

Error types for levelup.

`level-test`

Easily run your level-* tests against all stores.

`level-compose`

Compose a database factory from abstract-leveldown and levelup layers.

`level-exists`

Check if a datum exists without reading its value.

`level-move`

Move a value to another key.

`level-capped`

Capped collections.

`level-create`

Insert a key if and only if it doesn't already exist

`level-create-batch`

Insert a batch of keys if and only if none of the keys already exist

`level-modify`

Modify an existing key in levelup. Uses level-lock. See also level-create and level-move.

`level-random`

Read values of random levelup keys.

`level-shared-batch`

Share batches and commit collectively

`batchlevel`

Batch all operations made on a levelup instance. Compatible with subleveldown.

`ltest`

Test function for levelup testing, based on level-test.

`level-probe`

Get the first record in a range, using an iterator or stream. NB. Not compatible with latest levelup.

`autolevel`

Automatically combine levelup with the right abstract-leveldown store for your configuration.

`level-lazy-open`

Lazily open a leveldown compatible backend.

`changeset`

Generate diff changesets for javascript objects, decomposing diffs into a series of puts and delete operations. The format is compatible with levelup batch operations. Useful to synchronize objects.

`levelup-defaults`

Change the defaults settings on a levelup instance by returning a new levelup instance that uses the same abstract-leveldown but different options.

`level-methods`

Useful meta information about levelup methods.

Replication

`level-2pc`

A two-phase commit protocol.

`level-couch-sync`

Replicate from CouchDB to LevelDB.

`level-master`

Master-Slave replication for levelup.

`level-merkle`

Uses merkle-trees to replicate data sets. Data must be sets and currently, deletes are not supported.

`level-replicate`

Master-master replication with levelup. Implements scuttlebutt style handshake, syncs data, then replicates real time changes.

`level-replicator`

Master-master replication. Same goal as level-replicate but different approach.

Tools

CLI, GUI and web interfaces for exploring data.

`lev2`

A complete REPL & CLI for managing LevelDB instances

`level-in`

A simple command-line utility for writing data to LevelDB via levelup.

`level-out`

A simple command-line utility for reading LevelDB data via levelup.

`level-key-list`

Command-line tool for quickly printing a list of keys in a LevelDB database.

`lev`

A CLI REPL interface for LevelDB.

`leveldb-repl`

Super simple REPL for LevelDB. Supports filter globbing.

`levelhud`

LevelDB GUI with an interactive console.

`levelweb`

A LevelDB GUI. Includes simple data visualization tools.

`level-cli`

Interact with LevelDB on the command line.

`level-explore`

A terminal program to visualize LevelDB data. Early stages.

`level-repair`

CLI tool to repair a LevelDB.

`leveldb-editor`

Edit a LevelDB from the command line.

`levelscan`

LevelDB command line scanning utility

`levelui`

A LevelDB GUI based on atom-shell (now called Electron).

Benchmarking & Debugging

`level-bench`

Benchmark abstract-leveldown and levelup stores.

`level-compare-forks`

Run benchmarks on different level-forks and see how they compare.

`level-log`

Log all levelup operations, including method calls.

`debugdown`

Log all operations made on an abstract-leveldown compliant store. For node and browsers.

`level-time`

Log levelup operations and their duration.

`level-dump`

Dumps all values and/or keys of a levelup or level-sublevel instance to the console.

`level-benchmarks`

Run benchmarks against levelup-compatible engines

Resources

`leveljs.org`

Website for Level

`level-community`

General discussion, cross-repo efforts and common information for projects in the community

`electron-demo`

Demo app loading LevelDB into an Electron context.

`browserify-starter`

Demonstrates bundling level for browsers using browserify.

`webpack-starter`

Demonstrates bundling level for browsers using webpack.

`level-awesome`

An open list of awesome Level libraries and resources.

`levelmeup`

Level Me Up Scotty! An intro to Node.js databases via a set of self-guided workshops.

Applications

Applications and libraries that use Level modules under the hood.

`ipfs`

A peer-to-peer hypermedia protocol to make the web faster, safer, and more open.

`clocker`

Track project hours

`copy-on-write`

A copy-on-write FUSE implementation

`chrome-localstorage`

CLI to manipulate Chrome and Chromium's localStorage on disk.

`cipherhub`

Encrypt messages based on GitHub SSH public keys

`code-music-studio`

Design musical algorithms

`level-todo`

A todo list using LevelDB.

`electron-crash-report-service`

Aggregate crash reports for Electron apps

`cross-street-indexer`

Blazing fast tile based geocoder that matches cross street (road intersections) entirely sourced by OSM QA Tiles.

`lt-core`

Time tracking library.

`npm-search`

An index of npm using levelup.

`connect-level`

A connect / express session store backed by LevelDB via levelup.

`hadron`

A hackable publishing platform using LevelDB as main database.

`groove basin`

Music player server with a web-based user interface. Uses levelup for the music library database.

`prerender-level-cache`

Prerender plugin to use level as a cache store.

`tsd`

Spin up a quick server to visualize time series data.

`appfeed`

Version feed for trusted application delivery

`arrivals-osx`

Watch a folder for audio and video arrivals and convert them to Apple-friendly formats.

`bleach-log-server`

Keep track of bleach levels for a hot tub or a pool.

`browserify-cdn`

Browserify CDN. Caches browserify bundles in LevelDB.

Legacy

Modules that are deprecated, archived or superseded. Listed here for the historical record.

Contributing

Module and resource authors are welcome and encouraged to add an entry for their work via a pull request. To add a module, edit modules/*.json and run npm run awesome to update README.md.

Level/awesome is an OPEN Open Source Project. This means that:

Individuals making significant and valuable contributions are given commit-access to the project to contribute as they see fit. This project is more like an open wiki than a standard guarded open source project.

See the Contribution Guide for more details.

License

MIT

Level / awesome

readme