Skip to content

Modules

Jump to bottom Edit New page
jacobgroundwater edited this page Oct 27, 2012 · 735 revisions

Search for modules with search.npmjs.org, toolbox.no.de, npmdocs and nipster.

Adding to this page

When you add a framework to this page, have a look at how others have done so, it should be a single item, with a link to the project's source code, and a short description (one line after formatting has been applied).

If you see a module without a description, feel free to edit the page and add it in, any contributions are appreciated.

When you edit this list, also add your module to library-compatibility so that users will know which versions of Node it was tested with.

Table of contents

Modules

Web frameworks

Routers

  • barista — A fast, flexible URL router & generator, similar to Rails / merb (repo)
  • beanpoll — Universal router with syntactic sugar
  • beeline — A laughably simplistic router for node.js
  • biggie-router — Router for the biggie framework. Inspired by Sinatra and JQuery.
  • Birbal — Pretty darn simple and clever router. Work underway to turn into a microframework!
  • choreographer — Your server is my stage — dirt simple URL routing for Node.js. Easy to use, easy to understand. Sinatra-style API.
  • clutch — no-frills web request router, supporting nested routes, regexp parameters
  • connect-route — Simple and fast router for Connect
  • connect-router — connect/express router
  • connect — Robust high performance middleware framework
  • copperhead — Connect compatible router middleware that supports content negotiation
  • crossroads — Powerful and Flexible routing library, works on the client-side as well and have support for advanced features.
  • dispatch — Regular expression URL dispatcher for Connect
  • escort — High-performance, advanced routing and URL generation
  • fastworks - High performance middleware framework with built in routing and Connect compatibility
  • filter-chain — Java ServletFilter style request chaining
  • journey — liberal JSON-only HTTP request router
  • middler — A middleware runner which can itself function as middleware, with routing
  • node-flask-router — Flask-inspired routing system
  • node-router — Simple Sinatra-like http server based on fu.js from the original node-chat demo.
  • node.routes.js — A simple url router
  • nozzle — web app/service framework
  • Route66 — Routing middleware for Connect 2.0. Request params, simple syntax.
  • router — A simple router with regex and sinatra like parameter support
  • sherpa — HTTP router/generator with support for regex and parameters

Static file servers

  • antinode — A simple static web server
  • bastard — Automatic minification, in-memory cache, automatic fingerprinting.
  • buffet — Performance-oriented static file server & middleware
  • connect — Connect's static() middleware provides flexible, high-performance, feature-rich static file serving
  • crud-file-server — Static file server supporting basic create, read, update, & delete for any kind of file
  • fastworks - Fastworks' static file module uses Lactate and supports Less and Javascript compilers/compressors
  • Lactate — An exceedingly fast & simple static assets handler, with a few electives.
  • Lightnode — Easy to understand. Fast. Provides simple framework. (hierarchical servers, delegation, caching, virtual hosts).
  • navajo - A simple web server with the ability to run PHP or Node code as well as serve static files (alpha)
  • Nitrode — A lightweight, super fast HTTP 1.1 with internal JS API
  • node-paperboy — A node.js module for delivering static files
  • node-static — A simple, rfc 2616-compliant static file server module with built-in caching
  • nodetoy — Static JSON file server that supports GET, POST and DELETE
  • nserve — A local development server, allowing for adjustable file transfer rate, mock web services and live reload.
  • oui — Web service server with great static files support
  • send — Connect's robust static file server extracted for general use, supports range requests, conditional-GETs etc
  • static-resource - Static resource handling for node.js
  • static - Static file handler using asynchronous streaming as JSGI middleware
  • statify — A static file server to make any directory available via HTTP from the command line.
  • Trailer — Everyone's favorite backend.
  • wup — A simple web server for quick tests. Install via npm install -g wup, start with wup, go to http://localhost:8080/.

Microframeworks

  • Agni — Simple and intuitive MVC web framework for node.js.
  • (fab) — A modular and concise async web framework for node.js
  • frank — yet another sinatra-like microframework for node
  • jqNode — Simple jQuery-esque API for small projects.
  • kaph — Not framework
  • Layers — A module to help create a layered web app with Express.
  • Monorail.js — Ultra leightweight MVC web framework.
  • mvc — A lightweight mvc layer for express inspired by [ZendFramework] (http://framework.zend.com/) on php.
  • Nerve — Microframework with simple array-based syntax for defining an app on top of node. (node.JS 0.1.30)
  • Ni — A minimalistic Node module / framework that makes setting up an MVC project a breeze
  • Picard
  • Pipe-Layer — Asynchronous HTTP router.
  • rapid-rest — Minimal overhead full-fledged REST server. Benchmark
  • restmvc.js — A simple library to help you quickly create RESTful webservices using Express, Mongoose, and MongoDB.
  • seki — simple front-end to an independent SPARQL
  • simplex (October 2009, node.JS 0.1.14)
  • vroom — A simple resource oriented web framework built on top of Node.js (November 2009, node.JS 0.1.16)
  • zappa (now zappajs) — CoffeeScript minimalist interface to express, socket.io and others.

Frameworks

  • actionHero — actionHero is a minimalist transactional API framework for sockets and http clients
  • archetype — A web framework leveraging Node.js
  • aries — Annotation based MVC framework
  • blueprint — Blueprint for a Startup. Middleware, & MVC routing over Node.js & Mongoose
  • broke — A porting of the most famous Django Web Framework
  • Capsela — A high-level, promises-based web framework with an emphasis on testability (see website)
  • Cargobox — Express port with better OOP
  • chain — An evented convention for building Node Applications (Stopped Development, for ejsgi)
  • Coffeemate — Push coffee-script into web development!
  • COKE — A lightweight MVC framework base on Express that speeds up your web development. (Rails like)
  • Crux — An MVC web application framework and project management utility, similar in some ways to Rails.
  • Derby — MVC framework making it easy to write realtime, collaborative applications that run in both Node.js and browsers
  • djangode — A framework that borrows some useful concepts from Django (March 2010, node.JS 0.1.30)
  • drty — A Django port to NodeJS. Many Django features, still under heavy development. (January, 2011, 0.2.6)
  • Drumkit --- DrumKit is a plugin-powered, full-stack Web development framework for Node.js.
  • Express — A robust feature rich web development framework inspired by Sinatra
  • Ext Core for NodeJS — Templating and some basic tricks of ExtCore and ExtJS(XTemplate,Ext.util.format)
  • Flatiron — an adaptable framework for building modern web applications. URL Routing with Director, templating with Plates, data management with Resourceful, middleware with Union (connect-compatible), plugins with Broadway, logging with Winston.
  • Geddy — A hackable Web-app development framework similar to Merb/Rails/Pylons/Django
  • GenJi — A low-level loosely coupled web framework for nodejs
  • Grasshopper — A feature-rich and flexible MVC framework for web applications and services, with integrated dependency injection.
  • JaxServer — Application server and framework with template and css engines
  • jimi — A framework for writing modular web applications in node.js (tutorial)
  • josi — An MVC web framework that's easy to pick up but doesn't get in the way. Also see here
  • Kassit — rapid building of client-side AJAX applications using Backbone and CoffeeScript
  • Katana — Easy to use, modular web framework for any Node.js samurai
  • Kiss.js — Web framework for node.js in CoffeeScript. Object-oriented, simple and sexy.
  • Locomotive — Effective MVC web development for Node.js inspired by Ruby on Rails
  • merlin — Object-oriented MVC framework relying on a robust set of conventions to minimize code. Also ships with optional plugins providing basic CMS-like functionality.
  • Meryl — Minimalist web framework! See wiki
  • Mojito — An MVC framework and JavaScript library for building full-featured, device-independent HTML5 applications running on both client (browser) and server (Node.js). See the Mojito Documentation Directory for more information.
  • Monorail.js — Ultra leightweight MVC web framework.
  • N-Ext — Ext.core, Ext.util and Ext.data packages in your NodeJS apps (includes a MongoDB proxy based on node-mongodb-native)
  • nCombo — A client-server framework for building desktop-like cloud applications
  • node-extjs — Run ExtJS4 data models on Node.js
  • nodemachine — A port of WebMachine to Node.js
  • nodepress — High-level web framework for nodejs, can be used as a blog by default
  • PieJS — A rapid development MVC framework. Inspired and similar in style/convention to CakePHP. In very active development.
  • pintura — REST-based web framework/middleware stack built for Ajax-style JSON-driven applications
  • Protos — Web Application Framework
  • QuickWeb — An application server for Node.js
  • RailwayJS — An MVC web framework, similar to Ruby on Rails, Express/Connect-compatible. Also see here (en) and here (jp)
  • Sayndo — Fast and flexible web server with customized routing and authorization
  • Seek — Small Javascript Web framework - mostly for learning purpose
  • SocketStream — A fast full-stack real-time web framework for single-page apps
  • spludo — A full featured web framework. Fully Async + MVC with DI, AOP and Storages. (tutorial + user-guide)
  • Stick — A modular JSGI middleware composition layer and application framework
  • Tower — Full Stack Web Framework for Node.js and the Browser, inspired by Ruby on Rails.
  • webjs — Simple HTTP / TCP development framework
  • Zeppelin — An early stage, low friction cloud development framework

Middleware

JSGI

  • auth - Handles Authentication (HTTP and cookie based).
  • cascade — Sequentially attempts multiple middleware apps.
  • commonlogger - A logger of HTTP requests.
  • compact - Join and compress frontend javascript.
  • compress - Gzip compresses (using node-compress) the response when appropriate based on request headers.
  • conditional - Handles conditional HTTP requests (If-Modified-Since, etc.)
  • contentlength - Sets Content-Length header.
  • csrf - Checks HTTP request for possible cross-site request forgery, flags dangerous requests.
  • extension - Transforms .extension to a RESTful Accept header
  • head - Handles HEAD requests (stripping body).
  • http-params - Converts HTTP parameters http- to headers.
  • media - Performs content type negotiation (per RFC2616) delegating to appropriate media handler.
  • redirect - Redirects to other URLs
  • rewriter - Rewrites defined paths to other paths.
  • routes - Simple RegExp based router
  • session - Session manager with pluggable storage handling
  • static - Static file handler using asynchronous streaming.
  • transporter - Share modules with browser, works RequireJS and Yabble
  • urlmap - Maps to different apps by path/URL
  • xsite - Handles JSONP, window.name, and cross-origin XHR (CORS).

Connect

  • bundle-up — A simple asset manager middleware for managing css and js files.
  • connect_facebook - Facebook session support for Connect
  • connect_json - Support for parsing JSON requests and sending JSON responses in Connect
  • connect-airbrake — Airbrake error reporting auto-setup middleware
  • connect-assetmanager - Asset manager for Connect for handling CSS/JS files
  • connect-assets - Compiled CSS/JS asset pipeline inspired by Rails 3.1
  • connect-auth — Connect authentication middleware, provides out-of-the-box implementations of HTTP (Basic & Digest), Twitter, Facebook, BitBucket, Janrain, Yahoo, Sina, Google, OAuth (1.0 server), Github and a couple of others....
  • connect-compiler — Development middleware to dynamically recompile derived files at serve-time.
  • connect-dojo — Connect middleware exposing the Dojo Toolkit
  • connect-domain — Asynchronous error handler for Connect
  • connect-force-domain — force all visitors onto a single domain
  • connect-http-signature — middleware wrapper for Joyent's HTTP Signature reference implementation
  • connect-proxy — Retrieve originating ip/host values when proxying to your connect app
  • connect-roles — Dynamic roles based authorization for connect/express, designed to work well with passport and everyauth.
  • connect-rpx - Use RPX with Node.js and Connect
  • connect-views - Serve your jades, markdowns, styluses like a static files
  • cookie-sessions — Secure cookie-based session store
  • dispatch — Regular expression URL dispatcher
  • everyauth — Connect authentication and authorization middleware, modular, configurable, supporting password, OpenId, Google, OAuth, Twitter, LinkedIn, Yahoo, Readability, Dropbox, Justin.tv, Vimeo, Tumblr, OAuth2, Facebook, GitHub, Instagram, Foursquare, Box.net, LDAP
  • express-chromeframe — Dead simple middleware to enable chromeframe on connect/express applications.
  • express-errors — Simple error handling
  • facebook-wrapper — Basic wrapper to the Facebook API, designed to work with Connect and Express
  • form2json — Decoder for form-urlencoded data that supports arrays of nested objects
  • formaline - full-featured module for handling form POSTs/PUTs (multipart/form-data, application/x-www-form-urlencoded ) and fast parsing of file uploads, it speaks JSON and it is also ready for use with middlewares like connect.
  • http-accept — Connect compatible middleware that parses HTTP Accept header fields
  • merge-js — Simple connect middleware for merging multiple js files and uglifying the result.
  • mincer — direct Sprockets assets manager port, with middleware for connect/express
  • minj — Serve minified javascript files with Connect/Express
  • monomi — Provides tools for handling tablet, touch, and mobile browsers
  • node_signedcookies — Extends Express's cookieParser() to read/write signed cookies.
  • node-facebook-session-cookie — eats facebook cookies from client FB.login() and makes the session available as req.fb_session
  • passport — Simple, modular, and unobtrusive authentication framework for Connect and Express.
  • pound — Pound is an high-level interface for Piler - The Awesome Asset Manager for Node.js
  • quip — Chainable HTTP response API
  • resource-router — A resource-oriented router to replace the default routing in express
  • resty — Quickly and simply build REST APIs with this connect middleware
  • session-web-sockets — Pass session to (Socket.IO-node) in a secure manner. Originally forked from bmeck/session-web-sockets
  • session.js — super simple session middleware for node.js, even has optional "magic" sessions which monkey patch the httpServer with one line!
  • trust-reverse-proxy - Trust (SSL) connections coming from (a) specific reverse prox(y)(ies)

Other middleware

  • buffet — Performance-oriented static file server & middleware
  • eventpipe — Provides an Event Pipe with the same API as node.js' EventEmitter
  • exedra — Express routes & functions loader
  • express-twitter — Twitter-specific OAuth support
  • googleclientlogin — Log in to Google services using CllientLogin method
  • http-auth — Node.js package for HTTP basic and digest access authentication.
    • htdigest — Node.js package for HTTP Digest Authentication password file utility.
    • htpasswd — Node.js package for HTTP Basic Authentication password file utility.
  • http-auth2 — HTTP basic authentication that supports multiple logins.
  • http-proxy-selective — Proxy server replace some remote static files with local ones
  • middler — A middleware runner which can itself function as middleware, with routing
  • node-evented — Extended EventEmitter
  • node-file-cache - Very small file cache for node.js http server.
  • node-force-domain — Force multiple domains to redirect (301) to a default one in your Express project.
  • Node-Http-Rewrite-Proxy — This module proxies and rewrites HTTP requests of all types. For this you can, if you want, use regular expressions.
  • node-reverse-proxy — A reverse proxy which forwards incoming HTTP requests to multiple back-end HTTP servers based upon HTTP Host header.
  • node-varnish — Connector for the Varnish cache telnet management protocol
  • notp — NodeJS One Time Password authentication, compatible with Google Authenticator
  • onion — Simple and flexible middleware stack that enables you to add a middleware layer to just about anything
  • protobuf_for_node — In-process JS-to-C++ communication using protocol buffer services
    • protobuf — A fork of protobuf_for_node with an npm package.
  • proxy-tamper — A proxy server that allows for the tampering of requests and responses.
  • socket-logger — JSON-parsable logs for Socket.IO that can push log messages to a client over Socket.IO.
  • subproxy - subdomain proxy (for example to proxy www.google.com with www.google.com.localhost)

Other

  • Alligator — Application Server on top of NodeJS (JSSP and SSJS support)
  • Bricks — Ultra modular web framework
  • Cluster — Extensible multi-core server manager (spark successor)
  • Common Node — Synchronous CommonJS compatibility layer that includes JSGI, jBinary, IO, Filesystem, System and HttpClient modules
  • Connect — Middleware framework packed with high quality / performance middleware
  • fugue — Unicorn for Node.js - Multiple node server instance manager with Unicorn-like features
  • js2 — Syntactic Sugar and Object Oriented Javascript
  • JSGI-Node — Asynchronous JSGI 0.3 Adapter for Node, for standards-based middleware
  • mime-magic — Proper MIME type detection library that wraps the libmagic functionality
  • mob — Mob - Cluster microframework with worker process specialization
  • mongrel2 — mongrel2 - Mongrel2 handler for node
  • multi-node — Launch multiple node processes for HTTP servers
  • Nitrode — A lightweight, super fast HTTP 1.1 with internal JS API
  • node-cgi — CGI adapter kludge (replaces Node's fast and famous event-based HTTP library)
  • node-digest — HTTP Digest authentication for NodeJS
  • node-elf-logger — Configurable HTTP logging library following the W3C Extended Log File Format specification
  • node-flags — node-flags - Flag handling library
  • node-mime — A super simple utility library for dealing with mime-types
  • node.ly — A simple URL shortener (currently not available on GitHub)
  • Q-Oper8 — Scalable multi-process manager for Node.js
  • solder — Combines and minifies JavaScript and CSS at runtime and build time
  • Spark — A command-line tool used to manage node server processes
  • Spark2 — Fork of Spark with some improvements.
  • Stereo — A simple drop-in multi-core node application controller
  • Unlimit — chaining to JavaScript without extending objects' prototypes
  • what — What - A Node.JS Web Container/Application Server
  • zen — Robust high performance middleware engine

Database

MS SQL Server

  • node-sqlserver — Microsoft Driver for Node.JS for SQL Server and Windows Azure SQL Database
  • node-mssql — A node.js MS SQL Server native driver
  • tedious — A pure Javascript implementation of the TDS protocol, for connecting to SQL Server databases
  • node-tds — Pure JS client to SQL Server

PostgreSQL

  • FastLegS - PostgreSQL ORM on top of node-postgres.
  • node-postgres — Well tested libpq binding and pure javascript PostgreSQL client
  • ORMnomnom - ORM that mimics Django's ORM, on top of brianc's node-postgres. Also supports SQLite via developmentseed's sqlite3.
  • postgres-js — Fork of postgres-js, adds parameterized queries and prepared statements.
  • postgres-js — Postgres protocol implemented in pure JS
  • sequelize - An easy-to-use cross-database Object-Relational-Mapper (ORM) for Node.JS. Supports currently MySQL, PostgreSQL and SQLite.

MySQL

  • db-mysql - Binary driver for MySQL (using libmysql). Part of the Node.js DB effort
  • node.dbslayer.js - Interface to DBSlayer (MySQL)
  • node-handlersocket — Pure JavaScript client for HandlerSocket Plugin for MySQL
  • node-mysql — A node.js module implementing the MySQL protocol
    • node-mysql-pool — connection pool for node.js on top of Felix Geisendörfer's MySQL client node-mysql.
    • node-mysql-cache — MySQL query cache for node.js on top of Felix Geisendörfer's MySQL client node-mysql.
    • node-mysql-queues — Wraps 'node-mysql' to provide mulitple query queues, allowing support for multiple statements and MySQL transactions.
  • node-mysql-native — Yet another pure JS async driver. Pipelining, prepared statements.
  • node-mysql-libmysqlclient — MySQL asynchronous bindings based on libmysqlclient
    • RDX - An object-relational mapper (ORM) for node. Backends: node-mysql-libmysqlclient.
  • node-poormansmysql — Asynchronous MySQL driver for node.js using the mysql command-line tool
  • node-mysql — Pure JavaScript MySQL async driver [obsolete]
  • patio - An ORM/query engine for node (Currently only MySQL). Supports MySQL
  • persist - ORM framework supporting MySQL and SQLite 3 relational databases.
  • persistence.js — An object-relational mapper (ORM) for node. Backends: MySQL.
  • sequelize - An easy-to-use cross-database Object-Relational-Mapper (ORM) for Node.JS. Supports currently MySQL, PostgreSQL and SQLite.

SQLite

  • node-sqlite — Bindings for SQLite3. Interface conforms to the HTML5 Web SQL API
  • node-sqlite — Fast asynchronous driver: New evented Node.js look, same great SQLite3 taste
  • node-sqlite3 — Full-featured, asynchronous SQLite bindings with query serialization/parallelization and verbose stack traces
  • persist - ORM framework supporting MySQL and SQLite 3 relational databases.
  • sequelize - An easy-to-use cross-database Object-Relational-Mapper (ORM) for Node.JS. Supports currently MySQL, PostgreSQL and SQLite.

Oracle

  • noradle — NodeJS gateway for oracle plsql server page and driver for javascript to call oracle stored plsql procedure and get result sets.
  • oracle — Database driver for Oracle

NoSQL and Key/Value

Mongo

  • easymongo - Extension for node-mongodb-native for easy interaction.
  • GridFS - Simple GridFS capabilities built on node-mongodb-native.
  • mongo-express - Web-based MongoDB admin written with express.
  • mongo-sync — A synchronous MongoDB driver for use with Common Node that attempts to closely approximate the MongoDB shell.
  • mongoclikker - Simple MongoDB data viewer
  • mongodb-viewer — NodeJS MongoDB web-based admin/viewer tool.
  • mongojs — Simple driver that emulates the mongodb API as much as possible.
  • mongolia — Flexible wrapper for the nodejs Mongo driver. Lighter than a ORM but easier to use than the driver.
  • mongoose-nested-set - A mongoose plugin implementing the nested set pattern for mongoose models
  • mongoose-paginate — Mongoose ORM (NodeJS) Document Query Pagination.
  • mongoose — Mongoose is a JavaScript library that provides an ORM for MongoDB.
  • Mongorito — Mongorito is an ODM for MongoDB. Hooks, validations, models, built-in caching. Everything you need is already there.
  • mongous — Mongous is a simple MongoDB driver that uses a jQuery styled syntax.
  • node-mongodb — Basic MongoDB client implementation in JS/C++
  • node-mongodb-native — A pure JavaScript driver for MongoDB.
    • node-mongoskin — A future layer for node-mongodb-native.
    • node-mongodb-wrapper — As close as possible to the command-line driver. Uses node-mongodb-native.
    • mongode — Very thin wrapper around node-mongodb-native that simplifies the API a bit.
    • N-Ext — Use Ext.data packages in your NodeJS apps (includes a MongoDB proxy based on node-mongodb-native)
    • mongoq — MongoDB is: mongoq('mongodb://localhost/db').collection('users').find().toArray(function(error, docs){})
    • mongo-lazy — Node-mongodb-native for lazy people. Don't ever open a collection again. Eat a piece of cake while doing parallel queries.
  • node-mongolian — Mongolian DeadBeef is an awesome Mongo DB node.js driver that attempts to closely approximate the mongodb shell
  • nosql-thin - Makes easier to work with MongoDB. Not an ORM. Not production ready.
  • Official driver - Vote for it on 10gen's tracker

Hive

  • node-hive — dead simple hive client using thrift api
  • node-thrift-hive — Hive client with multi versions support and a Readable Stream API.

Redis

  • awesome — a Redis clone in node.js
  • haredis - High-availability/load-balancer wrapper around node_redis
  • nedis — Redis server implementation written with node
  • node_redis — Complete Redis client that works well with new node and new Redis
  • nohm — Redis object relational mapper (ORM)
  • rdb-parser — async streaming parser for Redis RDB dumps
  • redback — a high-level Redis library with support for advanced data structures such as Social Graphs and Full-text Indexes.
  • redis-node-client — Redis Client by Fictorial (deprecated)
  • redis-node — Comprehensive, high speed Redis client
  • redis2json — Easily loads data from Redis into structured JS object
  • ron — Redis object relational mapper with a minimum of magic
  • orpheus - Redis DSL for CoffeeScript.

CouchDB

  • couch-ar — a active record implementation for couchDB (uses cradle)
  • couch-client — a simple wrapper around CouchDB's http interface
  • couchcmd — CouchDB command line utility using cradle
  • couchtato — CouchDB database iterator tool
  • couchpenter - CouchDB database and document setup tool
  • cradle — a high-level, caching, CouchDB client
  • data.js — Graph persistence for Node.js with CouchDB
  • LazyBoy — a CouchDB ORM thats easy to use
  • nano — Minimalistic driver for CouchDB based on mikeals/request
  • node-couch — a CouchDB connector
  • node-couchdb-api — An easy-to-use and powerful wrapper for the CouchDB API that follows Node.JS conventions for async code.
  • node-couchdb-min — Light-weight client with low level of abstraction and connection pooling.
  • node-couchdb — A full API implementation
  • PJsonCouch — PJs-on-Couch is a client lib for CouchDB's HTTP API
  • Sag — Gently wraps the CouchDB API, giving you power without a bunch of "stuff". The same source file works in the browser, allowing you to code against one API everywhere.
  • YACA — custom api for your couchdb instance generated through introspection.

Other NoSQL implementations

  • alfred — a fast in-process key-value store for node.js that has functional indexes, streams, replication, ...
  • barricane-db — a transparent object persistence mechanism
  • cassandra-node — Node.js driver for CQL and Apache Cassandra
  • chaos — Chaos is a Node.js database
  • dynode — A client for Amazon's DynamoDB service
  • keys — Unified interface for key/value store clients
  • kyoto-client — A client for the Kyoto Tycoon key-value store
  • neo4j — Neo4j graph database driver for Node
  • node-dynamodb — DynamoDb Driver for Node.js
  • node-leveldb — NodeJS bindings to levelDB - a fast and lightweight key/value database library
  • node-mwire — Client for GT.M & Cache databases
  • node-tokyocabinet — Tokyo Cabinet binding
  • node-tyrant — An implementation of the Tokyo Tyrant network protocol for the Node.js
  • riak-js — Riak JavaScript client (works on node v0.1.30+)

Miscellaneous and multiple DB

  • db-drizzle - Binary driver for Drizzle (using libdrizzle). Part of the Node.js DB effort
  • db-migrate - Relational database migration framework
  • dynamoDB — An Amazon AWS DynamoDB library for Node.js.
  • hive — Fast in memory store for Node.
  • JSLINQ — Clean and simple port of Microsoft's LINQ to node.js (and the browser)
  • jugglingdb - ORM for every database: redis, mysql, neo4j, mongodb, ...
  • LDAP - LDAP Search/Modify/Auth with Syncrepl Async update notification
  • memcached — Memcached, membase client with support for memcached clusters using consistent hashing.
  • Memcacher — Memcached client, based on node-memcached, adds tagging functionality to memcached, without modifying it or its source.
  • Model - An ORM for Riak/MongoDB/Postgres/more that uses Mongo query syntax, loosely based on DataMapper
  • nconf — A hybrid local / remote configuration storage library
  • nocr-mongo — NoCR implementation for mongoDB
  • node-cask — A 140 loc mmap-ed key/value store, based on bitcask
  • node-dbi — "A la Zend Framework" database abstraction layer, offering a single handy API for MySQL, SQLite and PgSQL
  • node-dbmon — Database Real-Time Monitoring Library
  • node-dirty — A key value store for node.js that is simple, fast & dirty.
  • node-firebird-libfbclient — Firebird SQL client fbclient wrapper
  • node-firebird — Pure javascript and asynchronous Firebird client for Node.js
  • node-fleet — a FleetDB Client
  • node-fsdocs — Simple, ACID and versioned file system-based document database for quick hacks
  • node-gdbm — GNU's GDBM wrapper library for Node.
  • node-hbase — HBase client with full API support through the REST connector
  • node-mdb — Node.js-based clone of AWS SimpleDB, using GT.M for data storage
  • node-mdbm — a client for GT.M and Cache, using an HTTP interface that is based on SimpleDB
  • node-migrate — Migrate - A database agnostic migration system for Node.js
  • node-odbc — unixODBC bindings for node. Query any database that has an ODBC driver.
  • node-orm — ORM for multiple drivers (MySQL, PostgreSQL, MongoDB)
  • node-springbase — Plug-and-play cloud relational data store for Node applications
  • node-sqli — Promise-based API for interacting with SQL databases.
  • node-tiny — An experimental in-process database similar to nStore.
  • persist - ORM framework supporting MySQL and SQLite 3 relational databases.
  • persistence — Multi-backend database/nosql system. Backends: Sqlite3, Postgres and Memory.
  • perstore — JavaScript persistence/object store with pluggable storage based on the W3C DB API
  • rawhash — Experimental in-memory key:value cache where keys are binary Buffers. Built on google-sparsehash and murmurhash3
  • searchjs — Library for doing easy native JSON SQL-style querying on JS objects/arrays. Implements JSQL, native JSON query language.
  • sequelize - An easy-to-use cross-database Object-Relational-Mapper (ORM) for Node.JS. Supports currently MySQL, PostgreSQL and SQLite.
  • simpledb — An Amazon AWS SimpleDB library for Node.js that is user-friendly and fault-tolerant
  • squel — Light-weight SQL query string builder (works in browser too).
  • Tabler - Access relational and NoSQL database backends using a generic SQL-inspired table interface (SimpleDB, JSON file available)
  • ueberDB — Transforms every database into a object key value store

Templating

  • Plates — Light-weight, logic-less, DSL-free, templates for all javascript environments!
  • asyncEJS — Asynchronous implementation of embedded JavaScript
  • bake — Templating engine for static files. Supports ejs templates.
  • bind-js — a simple templating engine for node.js that smiles back.
  • Blade — HTML Template Compiler, inspired by Jade & Haml. Express compliant
  • bliss — Template engine inspired by .NET Razor and Play! Scala Templates.
  • blue — A streamed template engine. Support for asynchronous loading of partials
  • CoffeeKup — Markup as CoffeeScript. Live demo and html2coffeekup
  • CoffeeMugg — Markup as CoffeeScript. A branch of CoffeeKup, supports closures, requires no compilation, extensible via view-helper libraries, like ActionView.
  • combyne.js — A template engine that hopefully works the way you'd expect.
  • doT.js — Concise and super fast javascript templates with customizable delimiters, streaming and partials support
  • DryKup — CoffeeKup-compatible markup for CoffeeScript. Supports closures and requires no compilation.
  • dust — Async, streaming & composable templates for the browser and node
  • Eco — Embedded CoffeeScript templates
  • ECT — High performance template engine with embedded CoffeeScript syntax (see demo)
  • ejs — Light-weight Embedded JavaScript implementation. Express compliant
  • fest — Fast and safe template, xml syntax
  • haml-js — Server side html generation using JavaScript. Parses haml templates and renders html.
  • haml.js — Faster / more compliant implementation of Haml. Express support
  • handlebars.js — The mustache-inspired templating library behind Ember.js
  • Jade — Haml-like template engine, fantastic error reporting, easier to read, higher performance. Express compliant
  • jazz — A readable template language for node.
  • JinJS — A port of Jinja, a Django Template-like templating language to Javascript
  • Jinsoku - High performance Javascript template engine inspired by Jade's power and doT's speed.
  • jm — Another Builder/Markaby/Erectory clone in JavaScript.
  • jqtpl — A port of the new jQuery template engine. Express compliant
  • jsdom — pure js implementation of the dom level 1 with some browser augmentation. Level 2 and 3 are being considered.
  • jshtml — Clean HTML, full JavaScript template engine. Inspired by the razor view engine used in asp.net mvc.
  • JSON Template — Minimal but powerful template language with multiple implementations. This is the CommonJS version, tested on Node
  • Kiwi — Simple yet powerful template engine based on jQuery Templates syntax, totally asynchronous, and built from the ground up with performance and modularity in mind. Express 3.x compliant.
  • less.js — official port of Less to JavaScript/node.
  • Liquor — A templating engine minus the code.
  • Lite(LiteXML) — A cross platform template engine base on xml/html and javascript expression
  • ltxb — Less-Than XML builder templates
  • minstache -- tiny mustache compiler producing stand-alone functions
  • minimal.js — a fast HTML+JSON template engine (both browser and Node.js compatible)
  • MinnaHtml.js - An async aware object based HTML template library
  • Mu (Mustache) — A Mustache engine that compiles templates into very fast rendering functions. Also streams the
  • node-dom — Javascript fast W3C DOM generation.
  • node-jst — A pretty high performance template engine implemented with JavaScript. Express compliant
  • node-pages — A simple template engine. Cacheable and Trackable.
  • node-properties — Simple property reader, externalise your configuration through JSON
  • Node-T — A fast django-like templating engine for node.js
  • node-template — Fast and light cached templates.
  • node-tmpl — basic templating system in node.js based on shorttag
  • node.magic_dom — A DSL for building HTML in node.js, similar to Python's Stan
  • nodejs-meta-templates — like php mixed with html, processed twice, 1st static data, 2nd dynamic data.
  • normal-template — Normal templates are simple, yet powerful. They are safe, usable in non XML/HTML contexts and portable to any programming language.
  • nTPL — Fast & Native extendable template system
  • nun — Totally asynchronous non-blocking template engine for node.js
  • nunjucks - A jinja2-inspired template system, more up-to-date than jinjs
  • Parrot — A lightning fast and lightweight templating engine for Node.js (Just 33 LOC!)
  • Pencil — Custom tags/components for Jade. Extend, mixin and inherit.
  • plates — A fast, non-intrusive engine (similar to weld, but faster).
  • PURE — Unobtrusive Rendering Engine. The HTML view and the JS logic remain strictly separated. Works with jsdom.
  • QEJS — Asyncronous Embedded JavaScript Templates with Q promises
  • shift.js — Standard interface to the Node.js template engines.
  • stencil — Renders asynchronous templates shared by server and browser
  • Swig — Fast and powerful Django-style templates for node.js. Express compliant.
  • Templ8 — A fast, lightweight, yet powerful & feature rich client/ server template engine based on Django style syntax
  • template.node.js — A light, fast, cached template module for node.
  • thunder — A lighting fast template parser for node.js. Express compliant
  • tmpl-node — a feature-rich template module for node.js
  • tob — Template Observer, allows self-reloading templates with your template engine
  • TOFFEE — templates with the elegance of CoffeeScript, by the makers of OkCupid. (Compatible with Express 2, 3, and the browser).
  • tpl — a general purpose template cli
  • TSN — A Templating System for Node.JS.
  • TwigJS — A port of PHP template engine (www.twig-project.org) to Javascript
  • weld — unobtrusive. portable. ANTI-TEMPLATING. Weld binds data to markup, and can generate markup based on your data.
  • whiskers — single-file, feature-sparse templating for node, express, and the browser
  • xmlb — XML builder templates
  • xmlbuilder-js — An xml builder for node.js similar to java-xmlbuilder.
  • xmlbuilder.js — An xml builder in JavaScript inspired by Ruby's Builder, Markaby, and Erector. rendering process.

CSS Engines

  • carto — Parses MSS templates and renders XML for Mapnik
  • ccss — Parses a JavaScript object and renders css.
  • csslike — Parses and compiles CSS, taking into account the most recent www-style proposals.
  • cssjanus — Converts left-to-right stylesheets to right-to-left, useful for projects that support right-to-left languages like Arabic.
  • CSSOM — Parses CSS into CSS Object Model.
  • Csster — Write CSS in JS or Coffeescript, with macros, color math, etc.
  • Inverter — Flips CSS from LTR to RTL and vice-versa.
  • less — Parses a LESS template and renders css.
  • sass.js — Parses Sass templates and renders css.
  • scss-js — Parses SCSS templates and renders css.
  • Stylus-Sprite — Extension for Stylus to generate sprite images
  • Stylus — Expressive, dynamic, robust CSS language written by the author of Express, Connect, Jade and more

Content Management Systems

  • AE86 — Static website generator. Easy to write custom tag as simple JavaScript function, clean and minimalistic template syntax.
  • blacksmith — A static site generator built with Node.js, JSDOM, and Weld.
  • bread — A file based static website/blog generator for node that uses markdown files as content providers.
  • Calipso — An express based CMS, very much work in progress.
  • DocPad — is a language agnostic document management system. It's actively maintained and supported by a growing community. It's also modular; so easy to extend and use in bigger systems. It already supports lots of markups and pre-processors through available plugins and powers many websites.
  • jslardo — A Social CMS, where users are able to register to the application, create their own models (mongoose schemas), views, controllers, websites and pages. Work in progress, keep updated!
  • LooseLeaf — Very simple blogging engine based on express, no-DataBase, only JSON.
  • MCMS — A Minimal CMS using GitHub flavored Markdown, Mustache templates and the filesystem.
  • MuContent — MuContent is a multisite and multilanguage cms in Javascript (Node.js) written with a central proxy for balancing the request on multiple client. Based on MongoDB for storage all content. Themes are based on Foundation framework and mustache.
  • Murray CMS — blog platform using express and mongodb.
  • NoCR — JCR-inspired Content Repository API for Node.js which maps your content model to a tree of nodes and properties. There is a MongoDB NoCR provider available
  • Nodepad — A nice basic web-based notepad.
  • Punch - A simple tool to generate HTML documents from Mustache templates and content stored in JSON & Markdown format.
  • reed — A Markdown-based blogging core backed by Redis and the filesystem.
  • nodeportal — Inspired from Liferay, its a portal cms. Currently in heavy development.
  • hexo - Node.js blogging framework. Inspired by Jekyll & Octopress.

Build and deployment

Compiling and building

  • asereje — Bundles and minifies your javascript and css files on demand. Forget about builds, hard deploys and cache forever.
  • asset-bundler — pack and create asset bundles, organize your scripts and stylesheets in different packages.
  • buildr — JavaScript project builder, compresses images, CSS and JS, bundles CSS and JS, checks JavaScript, supports subpackages/plugins
  • Grunt — a task-based command line build tool for JavaScript projects.
  • Jake — JavaScript build tool similar to Make or Rake.
  • Masson — Build system and rule management similar to tools like Make, Ant or Rake
  • mnm — Make Node Module (MNM) is a build tool for making native Node.js modules with no dependencies other than Node itself (i.e. no Python required)
  • muffin.js — CoffeeScript compilation, minification, concatenation, copying, growl, and SLOC counting helpers for Cakefiles.
  • nib.js — package and minify JavaScript/coffeescript projects to be embedded in the browser as a single .js file
  • node-linter — generic lint wrapper for JSLint, closure-linter, closure-compiler, and JavaScript Lint.
  • simple-watcher - Coffee-script, haml and sass simple watcher
  • weber — dynamically compiling and minifying scripts, stylesheets and templates on-the-fly, including Coffeescript, Eco, Stylus, etc.
  • kaffee — a software project management tool and framework similar to Maven.

Restarting and continuous running

  • always — A CLI & Daemon tool to run a NodeJS process forever, restarting on file changes & crashes with piping to stdout or log files.
  • autorestart — It is a way to watch all .js files if they have been changed and to restart nodejs. It allows easy development and stable production.
  • dev — Automatically restarts the app when a source-file is modified. Autohooks on new files, so it doesn't need manual restart at all.
  • forever — A simple CLI tool for ensuring that a given script runs continuously (i.e. forever)
    • forever-webui — A simple web UI for efficient nodejs administration
  • forewoman — A port of foreman (process management tool) + hot code reload.
  • node-dev — Automatically restarts node when a source-file is modified. Displays notifications via Growl.
  • nodemon — Monitors all source files, restarts node on changes. Command-line usage, code-passive with ignore list.
  • reloader — Reload app on it's source code change. Suitable to work both on production and development machines. Act as usual NodeJS module.
  • run — Rerun your js file whenever there's a change in the current directory: npm install -g run, runjs yourcode.js. Never alt-tab to your terminal again.
  • start-stop-daemon — Easily transform JS scripts into start-stop-daemon scripts
  • winser — Run Node.js applications as services on Microsoft Windows.

Deployment

  • [azure] (http://github.com/windowsazure/azure-sdk-for-node) - Deploy and manage node.js applications to Windows Azure, create Linux and Windows Virtual Machines and more.
  • connect-girror — Connect middleware which mounts an entire app from any git repository, spawns it and exposes a git post-receive hook endpoint.
  • girror — Mirrors (and re-mirrors) git repositories.
  • Gittyup — Application deployment library for node.js
  • gogogo - Easy automatic deployment and management to any server with upstart (ubuntu)
  • haibu — a node.js application server - spawn your own node.js clouds, on your own hardware
  • jitsu — Flawless command line deployment of your Node.js apps to the cloud
  • npkg — Generates cross-platform installers for Node.js applications
  • roco — Capistrano inspired CLI for deployment, monitoring and other stuff.

Configuration management

  • coffee-conf — Write your config files in coffee-script.
  • config — Configuration control for production node deployments - npm install config
  • configme — Simplest possible configuration tool. without conflict - with defaulting!
  • envious — environment variable configuration that's too easy to pass up
  • node-config — Lightweight configuration engine for Node.js
  • node-ini — A simple .ini config parser that supports sections, comments, arrays, and objects.
  • node-settings — Simple, hierarchical environment-based app settings.
  • osenv — Gets environment settings of the operating system.
  • ripple — Dynamic runtime configuration for node.js deployment based on lorenwest's config.
  • pkgconfig - Reads and validates JSON configuration files for Node.js packages.

See also parsers, they may be used to parse configuration files.

Miscellaneous build and deployment tools

  • coffee-toaster — Minimalist dependency management system for coffee-script.
  • doc.md — A simple JSDoc documenation tool that creates markdown for node.js modules
  • modul8 — Extensible CommonJS browser code sharing
  • nclosure — Compiler, Style Checker, Utility Library, Unit Testing Framework, JSDoc Documentation Tool. Built on top of Google Closure tools.
  • node-foreman - A Node implementation of Foreman with Node-specific additions.
  • octoploy — GitHub post-receive hook URL handler (execute script on push to repo)
  • poly.shell — distributed shell job control with role based configuration
  • quickcheck — Port of the Haskell QuickCheck unit testing framework
  • ready.js — continuous javascript integration
  • ndoc — direct PDoc port with some extra features.

Package Management Systems

  • Cupboard — Reverse package manager
  • Ender — A package manager built on NPM bringing micro to macro to create your own custom JavaScript library by composing modules into a cohesive and familiar interface .
  • nmod — nmod is a node_modules manager. able to install from npm and git
  • npkg — Generates cross-platform installers/executables for Node.js applications
  • npm — A node package manager that uses CommonJS-compatible package.json files, written in asynchronous JavaScript.
  • police — A module dependency version policing tool. It goes through all your repositories on github which has package.json and analyzes the dependencies and reports back to you about all the outdated packages.
  • Slugr — Wraps node.js apps into a single executable file.

Module Loader

  • a3 — a3 module loads any folder of code into an 'API Tree'
  • directory — require a whole directory
  • haba — plugin library
  • node-DJs - Restart a server after each change in main script and dependencies
  • node-hot-reload - watchFile and reload modules dynamically for node.js (very useful for development, less good for production)
  • nodules — Async URL CommonJS module loader with dep resolution/downloading and hot-module reloading
  • remap - reroute require for mocks, wrappers, or shenanigans (useful for testing)
  • sourcemint-platform-nodejs — sourcemint-loader-js (optimized CommonJS package mappings based JavaScript module loader) for NodeJS
  • remap - reroute require for mocks, wrappers, or shenanigans (useful for testing)
  • wrapit - webservice to wrap any web resource in a header and footer; good for wrapping javascript files in require calls
  • express-load — Autoload scripts (routes, controllers, models...) into the Express application instance.

OpenSSL / Crypto / Hashing

  • amir's node-base62 — C++ base62 lib for representing big numbers
  • brainfucker's node-base64 — C++ base64 lib
  • hashlib — Fast hashing module, written in C/C++, supports: md4, md5, md6, sha, sha1, sha256, sha512
  • jsHashes — A hash algorithm independent library purely JavaScript implemented for both server and client side. Support: MD5, SHA1, SHA256, SHA512, RIPEMD-160, HMAC including Base64 encode/decode, CRC-32 and full UTF-8 support.
  • keygrip — Key signing and verification for rotated credentials
  • MD5 — Plain JavaScript MD5 hashing function
  • murmurhash3 — Node.js bindings for MurmurHash3
  • node_nibbler — Base32/base64 encoder/decoder.
  • node-cityhash — NodeJS bindings for Google CityHash , both CityHash64 and CityHash128 are supported.
  • node-crypto — OpenSSL based Hashing, Signing and Verifying
  • node-gpg - GPG encryption and decryption by way of the gpg command-line tool
  • node-keychain - Basic Keychain Access on Mac computers running Node.js
  • node-hashring — Hash ring provides consistent hashing based on the libketema library.
  • node-oauth — OAuth client (1 and 2)
  • node-oauth2-provider — OAuth 2 provider as Connect/Express middleware with custom token storage hooks
  • node-openid — OpenID 1.1/2.0 Relying Party (client)
  • node-phpass — A pure JavaScript port of the portable PHP password hashing framework.
  • node-sechash — Secure password hashing using salt and key stretching.
  • node-whirlpool — C/C++ mhash lib wrapper providing whirlpool hash support
  • node.bcrypt.js — C/C++ bcrypt lib
  • NodeJS-Keychain — A security-oriented keychain web service
  • oauth-server — OAuth server (1.0A)
  • oauthjs — OAuth client
  • packnode — Obfuscate, minify and/or encrypt JS files
  • pass — Validate/generate Apache htpasswd passwords (for Basic Auth)
  • pkrumins's node-base64 — C++ base64 lib that actually works
  • rbytes — Secure random byte generator for session keys, UUIDs, etc.
  • S3ncryptedProxy — A simple proxy that makes securely sharing data via Amazon S3 easy
  • sasljs — Gsasl wrapper to performs server-side SASL authentication.
  • sha1 — Plain JavaScript SHA-1 hashing function
  • simple_rsa_encrypt - A simple OpenSSL RSA module for node.js, to integrate rsa public encryption and private decryption.
  • speakeasy — Easy two-factor authentication. Time-based or counter-based one-time passwords with the HMAC One-Time Password algorithms. Supports Google Authenticator.
  • ursa — A clean and reasonably complete set of wrappers for OpenSSL's RSA functionality.
  • xml-crypto — Xml digital signature and encryption library for Node.js - written in pure javascript.

SMTP

  • emailjs - send emails, html and attachments from node.js to any smtp server (ex: gmail)
  • Haraka — Full Featured SMTP Server
  • mailcomposer - Generate e-mail messages that can be streamed to SMTP or file (unicode friendly)
  • Mailman — Send emails in a comfortable way via models. SMTP, SES, Sendmail supported.
  • node_mailer — send emails from node.js to an smtp server, simple as cake
  • node-smtp — Implementation of an SMTP server (and soon, client)
  • node-smtpevent — Event based SMTP server
  • Nodemailer - Easy to use module to send e-mails with Node.JS, unicode friendly
  • simplesmtp - Use SMTP as a first class protocol, useful for generating custom SMTP servers

No Longer Maintained

TCP / IP

Multiple protocols

HTTP

  • curler — Native c++ node.js module for asynchronous http requests via libcurl.
  • fetch — Fetch urls with ease, supports gzip content, cookies and more
  • http-get — Simple to use node.js HTTP / HTTPS client for downloading remote files. Supports transparent gzip decoding. May use some HTTP or HTTPS proxy.
  • http-sync — Synchronous http(s) client
  • multiparter — multipart/form-data POST request maker for Node.js with support for streams (sending files) and plain params
  • multipost — An easy interface for the multipart/form-data protocol
  • needle — Lightweight HTTP client with multipart support.
  • node-digest — HTTP Digest authentication for NodeJS
  • node-get — Moderately higher-level HTTP client library.
  • node-tunnel — HTTP/HTTPS Agents for tunneling proxies.
  • poster — Upload local/remote files over multipart.
  • request — Simple HTTP client library.
  • shred — HTTP client library for Node.js and browsers. Supports gzip, cookies, https, proxies, and redirects.
  • superagent — High-level HTTP client sporting a progressive API
  • watchmen — A simple HTTP monitor (pings sites and services with predefined parameters to make sure they are alive)
  • node-crawler — Web crawler/spider with JSDom, jQuery & connection pooling.

FTP

  • ftp-get — Simple to use node.js FTP client for downloading remote files
  • jsftp — A sane, light and concise client implementation of the FTP protocol
  • node-ftp — An FTP client module for node.js
  • node-ftpclient — Node FTP Client
  • NodeFTPd — Node FTP Server ... updated fork here

E-mail

  • inbox — Super easy access to IMAP mail server mailboxes
  • n3 — Experimental POP3 server to send arbitrary data to e-mail clients (including e-mails)
  • node-imap — A module for interacting with IMAP mail servers
  • node-poplib — POP3 client library for Node.js

XMPP

Other networking

  • jsDAV — jsDAV allows you to easily add WebDAV and CalDAV support to a NodeJS application. jsDAV is meant to cover the entire standard, and attempts to allow integration using an easy to understand API.
  • macaddr — Obtain MAC addresses for current machine from Node
  • mdns — mdns/zeroconf/bonjour service discovery add-on
  • ndns — DNS client/server library
  • node-hydna — Bindings for the Hydna platform
  • node-icecast-stack — An interface for connecting to, parsing metadata, and reading from SHOUTcast/Icecast radio streams
  • node-nntp — An NNTP (usenet/newsgroups) client module for node.js
  • node-ping — Simple wrapper around fping
  • node-snmp — SNMP v1 client
  • node-snpp — Node SNPP server library
  • node-ssltunnel — A lightweight TCP over SSL / TLS tunnel running over node. If you need to add confidentiality, integrity, and authenticity to your TCP stream this is the tool for you.
  • node-tld — for working with TLD data (registered domain name, etc)
  • NodeSSH — a lightweight SSH client
  • portscanner — An asynchronous port scanner for Node.js
  • radius — RADIUS packet encoding/decoding library
  • shorty — Shorty is a lightweight, high performance SMPP client and server.
  • stomp-client — A STOMP client for Node.js
  • wake_on_lan — Generate and send Wake-on-LAN magic packets

RPC

  • bertrpc
  • dnode — Asynchronous remote method calls with transparently wrapped callbacks. Works with regular network streams or socket.io.
  • IPCNode — Asynchronous RPC library based on node.js Stream object, with support for circular objects, and explicit reference counting to ensure proper garbage collection.
  • jayson - Featureful client and server implementation of JSON-RPC 2.0 (supports automatic forking, reviving/replacing, binary client etc.)
  • json-rpc-server — Simple implementation of JSON-RPC 2.0 server-side protocol with middleware support. Needs HTTP or any another server to communicate with clients.
  • jsonrpc
  • jsonrpc2 — A super easy to use JSON-RPC v2 server
  • messenger — Dead Simple API for cross-service communication (supports Pub/Sub, Request/Reply, Fire and Forget models).
  • msgpack-rpc — Implementation of Msgpack-RPC (http://msgpack.org)
  • node-ipcbuffer — A modified Buffer object to pass large amounts of data between processes using POSIX or System V IPC shared memory and or do fast read and writes to files. (Windows soon).
  • node-jsonrpc — Another JSON-RPC server
  • node-pingback — Pingbacks for node.js, conforming to the pingback and xml-rpc spec.
  • node-soap — SOAP client and service (partial support).
  • nodejs-light_rpc — Simple server/client RPC, with minimal dependencies (uuid (can be removed to use simple increment)).
  • nodeQuery — nQuery.js lets you create, edit, update or delete the DOM in real-time using jQuery/Zepto style code written on the server
  • nowjs — nowjs makes realtime web apps really easy (http://nowjs.com)
  • rpc-socket — Multi socket support for JSON-RPC NOTE: still under development.
  • thintalk — A minimal extendable RPC abstraction with buildin TPC and IPC support
  • xmlrpc — A pure JavaScript XML-RPC server and client
  • zeromq.node — 0MQ (zeroMQ) bindings for node.js
  • ws.js — A WS-* client stack for node.js. Written in pure javascript!
  • wcf.js — A WCF-compatible web service client stack for node.js. Written in pure javascript!

Web Sockets & Ajax

  • Abstract HTTP Request — An HTTP Client wrapper for the browser (XHR) and node.js (http module)
  • Beseda — Fast, well designed and featured Node.js Pub/Sub server. Beseda offers multiple platform API to develop realtime web applications.
  • Comet LongPollingBuffer — A Library to simplify the server side of Comet AJAX long polling
  • easywebsocket — WebSocket to broadcast messages to webpages
  • Faye — Bayeux protocol Comet client and server for Node.js and Rack
  • grappler — A minimalistic server for handling "comet" connections that supports a variety of connection methods.
  • Minotaur — Long poll server using JSONP communication with clients
  • node-bus — A distributed pubsub engine for JSON-based events
  • node-eventstream — A server-side companion to EventSource.
  • node-object-sync — Transparently synchronize objects across connected clients
  • node-rpc-socket.io — socket.io addon, add a full client/server implementation of JSON-RPC
  • node-socket.io-client — Node.js implementation of the Socket.IO client libraries
  • node-websocket-client — An HTML5 Web Socket client.
  • node-websocket-server — Another websocket server on top of the http server.
  • node-wwwdude — A simplified, flexible HTTP/REST client library for node.js
  • node-XMLHttpRequest
  • node.websocket.js — WebSocket-compatible server.
  • node.ws.js — A basic Web Socket server with interface similar to tcp.createServer(...)
  • node2node-socket.io — A node2node transport and client for socket.io .
  • nodejs-http-websocket — A websocket server on top of the http server.
  • Restler — Simplified REST client for Node.js
  • Reston — REST client with multipart support and friendly API
  • Socket.io — WebSocket-compatible server and client with fallback for legacy browsers
  • spacesocket — WebSocket server not invented here
  • tunguska — A comet publish/subscribe distributed hub (runs across multiple node instances).
  • wave-node — An implementation of the Google Wave Gadget API for node.js
  • Weasel — a command based websocket application framework
  • websocket-node — A WebSocket library that implements the most current protocol versions, 8 and 13. Version 13 is the latest version that is now the final WebSocket spec as RFC 6455
  • ws-flash-client — Replaces the WebSocket object with a Flash implementation on clients without native WebSocket support, thus covering 99% of use cases. Works well with the ws WebSocket server.
  • ws-rpc — Lightweight RPC support for the ws WebSocket server. Supports rooms (channels), callbacks, auto-reconnection, using client WebSocket from Node.js (not only Browser), and works well with ws-flash-client.
  • ws — Very fast, protocol conformant WebSocket client, server and console. Supports RFC 6455, the Hybi drafts as well as Hixie-76.
  • ReWebSocket — auto-reconnecting WebSocket, 99% API-compatible with the original WebSocket (decorates any WebSocket implementation)

Message Queues

  • kue — Kue is a priority job queue backed by redis, with a clean & simple UI
  • amqp-dsl — Fluent Interface for dealing with AMQP (RabbitMQ,...) on NodeJS
  • amqp-tool — Import & export data from/to an AMQP/RabbitMQ broker
  • fairy — a queue engine based on Redis offering ActiveMQ's message groups alike feature.
  • gearman-node — Gearman client.
  • gearnode — Gearman client and worker.
  • messagehub - Simple message, queue and pub/sub system compatible with AMQP/RabbitMQ
  • MongoMQ — MongoMQ is a messaging queue built on top of Node.js and MongoDB's tailable cursors. It allows for distributed of messages across workers in both a single reciever and broadcast method.
  • node-gearman — Simple worker/client module for Gearman
  • node-rqueue — Implementation of RQueue, includes Worker and Queue
  • QDis — a simple durable fanout pub/sub queueing system built with Redis + Node.js
  • Que — One model-based interface to many message queue backends.
  • rabbit.js — Idiomatic messaging using RabbitMQ from node.js
  • rabbitmq-nodejs-client — rabbitmq client for node.js
  • websocket.MQ — Reliable message queue server accessible via websockets, socket.IO, etc
  • Wormhole — Fast/High Performance message queue system using streaming deserialization with the MessagePack format.

Class systems

  • Bike — Class system to organize namespaces, define, create, extend, mixin, super inheritance and more.
  • class-js — Simple, Light-weight OO Class factory
  • comb — Library with a built in OO class system, and other features(datastructures, array string and date utilities, etc..).
  • ease.js — Classical Object-Oriented framework for JavaScript
  • joose — complete modern class system for JavaScript, based on concepts from many programming languages
  • mootools.js — MooTools latest server library as npm package for node.js
  • N-Ext — Use the power of the Ext.data packages (from the ExtJS framework) in your NodeJS apps. Includes a MongoDB proxy based on node-mongodb-native)
  • node-interface — Interface that defines the signature of the methods that must be implemented.
  • Sslac — Basic OOP-like support in JavaScript using chaining. Supports extension, interfaces, namespacing, and static objects.
  • Structr — Library built to give JavaScript the same look and feel as other popular languages such as Java.
  • UberClass — A class framework based on John Resig's Simple JavaScript inheritance and JavaScriptMVC $.Class.
  • UberProto — JavaScript object inheritance sugar: Initialization methods, easy extension, mixins, super methods, proxies

Testing / Spec Frameworks

  • API Easy — Fluent (chainable) syntax for generating Vows tests against any RESTful API.
  • benchmark-pages — A benchmarking library for your web service that measures page response time under different loads.
  • Benchmark.js — A benchmarking library that works on nearly all JavaScript platforms, supports high-resolution timers, and returns statistically significant results.
  • Broke — Customizable vowsjs layer for flexible unit and integration tests.
  • Cucumber — The official JavaScript implementation of the well-known BDD tool. Runs both on Node.js and browsers.
  • cucumis — A cucumber nodejs implementation. Run plain text gherkin stories with full asynchronous support in native node.js JavaScript.
  • Cup of Tea? — BBD-style Unit Testing for Async apps.
  • databasecleaner — Clean your database after each test. Supports MongoDB, Redis and CouchDB. Will support MySQL and others.
  • datagen - Multi-process test data files generator
  • dokimon — A nodejs module used to setup automated tests of various kinds.
  • ensure — nodejs testing made easy with vows or node-tap
  • espionage — A mock/stub framework using the test spy pattern.
  • exemplor.js — A port of exemplor with Node goodness.
  • expresso — TDD framework by the author of JSpec
  • fake-fs — Fake file system for testing
  • fakeredis — Simulated Redis instances, so that you can run any number of redis-dependent tests in parallel.
  • fakeweb — A port of fakeweb that fakes out requests made via Mikeal's request module, or the standard HTTP module.
  • foounit — client/server side BDD testing framework
  • Gently — A node.js module that helps with mocking and behavior verification.
  • Gerbil — Gerbil attemps to be an uber simple and minimalistic testing framework for javascript.
  • gherkin — A fast Gherkin parser in Ragel (The parser behind Cucumber)
  • grover — PhantomJS/YUITest CLI test runner.
  • horaa — Mocking NodeJS Modules
  • httpmock — A RESTful web API for stubbing out network dependencies.
  • jasmine-jquery — jQuery matchers and fixture loader for Jasmine framework for node forked from Jasmine-Jquery
  • jasmine-node — integration with Pivotal's Jasmine Spec framework
  • jessie — Node runner for Jasmine JavaScript BDD testing framework
  • Jody — A descriptive BDD Testing framework
  • jspec — Feature Rich BDD Testing Framework (no longer supported)
  • JUTE — A JS testing environment with built in code coverage support for Capture/Selenium/V8 backends
  • kin - Object creator using blueprints
  • kyuri — A node.js cucumber implementation with a few extra asynchronous keywords. supports 160+ languages and exports to VowsJS stubs
  • maryjane — Mock object library inspired by Mockito
  • minitest.js — Light-weight & simple testing framework designed specially for testing asynchronous code.
  • mjsunit.runner — Command line mjsunit runner which provides an easy way to hook into mjsunit and start running tests immediately.
  • mocha-cakes — BDD mocha test framework add-on, stories with Cucumber style Given/When/Then syntax for Node.js
  • mocha — simple, flexible, fun javascript test framework for node.js & the browser
  • mockery — Simplifying the use of mocks with Node.js
  • nock — HTTP mocking and expectations library.
  • node-assert-extras — Additional high level asserts
  • node-assertthat — Provides a fluent TDD style for Node.js: assert.that(actual, is.equalTo(expected));
  • node-async-testing — Simple, fast, extendable unit testing.
  • node-qunit — QUnit port for nodejs. Very simple API, async testing, good tested testing framework.
  • node-replay — When API testing slows you down: record and replay HTTP responses like a boss.
  • node-stories — Given/When/Then integration awesomeness for Node.
  • node-testy — Super simple testing script. No added sugar. 100~ LOC.
  • nodemock — Simple Yet Powerful Mocking Framework for NodeJs
  • nodeunit — Simple syntax, powerful tools. Based on the assert module. Available for node.js and the browser!
  • patr — Promise-based asynchronous test runner: lightweight & simple.
  • pit — Simple drop-in test runner with optional control tools
  • platoon — A javascript testing framework whose goals are to work gracefully with callbacks, both in node.js and the browser
  • pretendr — Yet another mocking function. Simple and lightweight, it lets you mock objects just by passing them as a single argument.
  • reut — Heavyweight unit testing framework.
  • should — expressive test framework agnostic BDD-style assertions
  • sinon — JavaScript test spies, stubs and mocks for Node.js and the browser
  • soda-runner — Provides a command line interface, runner, and selenium ide adapter for for soda.
  • Soda — Selenium Node.JS adapter
  • spectacular — for testing
  • speculum — BDD Test Suite.
  • Speks — A specification framework for your node-code
  • stest — A sane event driven async testing framework.
  • supertest — HTTP test utility built on top of superagent, works with any test framework
  • Syringe — Dependency mocking for node modules
  • tbd — A data generator for tests & UI stubbing
  • TestIt — Light-weight yet complete, shoulda style testing framework for in-browser and node.js tests.
  • TestNode — Unobtrusive BDD-style testing framework
  • testosterone — Virile testing for http servers or any nodejs application.
  • Tobi — Expressive server-side functional testing with jQuery.
  • twerp — Simple test framework which is suited to Coffeescript users. Synchronous, simple and easy.
  • uubench — A tiny asynchronous JavaScript benchmarking library
  • vbench — tiny visual benchmarking library powered by uubench and node-canvas
  • Vows — asynchronous behaviour-driven development for node.js
  • whiskey — A simple test runner for NodeJS applications.
  • yeti — The YUI Easy Testing Interface: run browser JS unit tests from the command line!
  • zap — a tiny testing tool for node.js
  • zombie.js — Insanely fast, full-stack, headless testing using node.js

Dependency Injection tools

  • Coffee-Injector — An asynchronous dependency injection container written in coffeescript.
  • rewire — Dependency injection for node.js applications
  • dependable - Automatic dependency resolution without tweaking require
  • Medic Injector - A light-weight Javascript Dependency Injection tool, strongly inspired by the great ActionScript3 RobotLegs framework and it SwiftSuspenders IoC container
  • the-box — Build systems style computational model for complex apps

Wrappers

Parsers

JSON

  • Amanda — JSON Schema validator
  • benejson — Includes pure JavaScript incremental JSON parser
  • json-diff — structured colored diff for JSON files
  • json-streams — Streamed JSON parser and stringifier
  • JSON.js — easy to use but synchronous, built-in to V8 (no need to @require@)
  • json2json — Transform (reformat) JSON from one structure to another using JavaScript
  • jsonsp — JSON stream parser for Node.js.
  • node-yajl — SAX-like evented JSON stream parser using yajl version 2 (fork of yajl-js)
  • props — Parse json or yaml from the beginning of text files.
  • yajl-js — SAX-like evented JSON parsing using yajl
  • jsvutil - A Node.js utility wrapper for the JSON Schema Validator (JSV).
  • js-schema - Simple and intuitive schema validator

XML

  • dom-js — A pure JS XML DOM based on sax-js
  • libxml-to-js — XML to JavaScript object converter based on libxmljs.
  • libxmljs-easy — Work with libmxmljs DOM as with plain Javascript objects, similar to E4X
  • libxmljs — Bindings to libxml2
  • node-expat — Fast SAX parser binding to expat
  • node-expat — a fork of Fast SAX parser binding to expat, also includes XML to JavaScript object converter
  • node-halfstreamxml — sax-js based, filter out nodes (with attributes and child nodes) from an xml stream by name
  • node-o3-fastxml — W3C Standards based XML DOM based on fastest xml parser in the world pugiXML
  • node-o3-xml — W3C Standard based XML DOM with XPath and namespaces. Built on libxml2
  • node-plist — Apple Plist parser for NodeJS. Convert a Plist file or string into a native JS object.
  • node-xml — An xml parser for node.js. (The github page for this module is showing some severe performance issues. Not recommended as an "out of the box" solution.)
  • node-xml2js — Simple XML to JavaScript object converter.
  • sax-js — SAX-like parser in pure JS
  • xml-events — XML stream parser, based on node-expat. Fires contextual events when it finds a descendant.
  • xml-object-stream — Low-memory streaming xml parser for node.js. Returns each node as an object. Uses node-expat
  • xml-stream — XML stream parser and editor, based on node-expat.
  • xml2json — Simple SAX based XML to JSON parser. It uses node-expat.
  • xmldom — A PURE JS W3C Standard based DOMParser and XMLSerializer (DOM Level2 CORE).
  • xml-crypto — Xml digital signature and encryption library for Node.js - written in pure javascript.
  • saxpath - Pure-JS XPath evaluator using a SAX parser.

Command line option parsers

  • aparser — Async ARGS parser
  • argparse — One of the most featured & flexible parser. Direct port of python's argparse module
  • argsparser — A tiny limited arguments parser, returns a hash.
  • argumentr — simple to use but powerful argument parser with free --help
  • celeri.js — Complete command line interfaces lib for node.js
  • cli — Rapidly build command line apps. Full featured opts/args parser + plugin support
  • COA — Command-Option-Argument: full featured command line parsing, async all the way, use user defined COA's as module with API, auto generate shells completions
  • commander.js — The complete solution for nodejs command-line interfaces
  • dreamopt — Command-line parser with readable syntax from your sweetest dreams
  • js-opts — Another simple command line option parser, easily installed via NPM
  • mingy — Command parser for CLI tool and adventure game needs. Works well with the optimist module.
  • node-named-argv - Simple module for passing named parameters to node app.
  • node-arguments — Yet another simple command line option parser
  • nomnom — Option parser with generated usage, support for callbacks and commands.
  • nopt — The command line options parser npm uses.
  • Operetta — A Node Option Parser That Sings!
  • optimist — Light-weight option parsing without optstrings or any of that silliness. It's just a hash!
  • options.js — An inline (non-module!) options parser that is very small and yet quite complete.
  • optparse-js — Option Parser in JS
  • parseopt — Flexible and extensible option parser in JavaScript.
  • tav — Brain-free command-line options parser for node.js
  • trollopjs — Another option parser
  • yanop — Yet Another Node Option Parser

CSV parsers

  • node-csv-parser — Full featured CSV parser with simple api and tested against large datasets.
  • node-csv — Efficient Evented CSV Parsing.
  • ya-csv — Evented CSV parser and writer with configurable separator, escape and quote characters

Markdown parsers

YAML parsers

  • JS-YAML — Full featured YAML parser. Native PyYAML port.
  • props — Parse json or yaml from the beginning of text files.
  • yamlish — Minimally featured YAML parser which handles the subset of YAML used by TAP.
  • yamlparser — A JavaScript YAML parser.
  • yamlprompt — A prompt that asks for YAML input. Depends on yamlparser.

Binary file parsers

  • bufferlist — Create linked lists of buffers and asynchronously parse binary data from these lists
  • butter — Butter === nodeJS Buffer + ( some hexadecimals delights )
  • epub — Parse EPUB electronic book files with Node.JS, load chapters, images etc.
  • jParser — Generates parsers for arbitrary data structures, parses binary files.
  • jspack — JavaScript library to pack ints, floats, etc. to octet arrays representing C data structures
  • musicmetadata — Get music metadata asynchronously from node streams.
  • protobuf_for_node — Protocol buffer parsing and serialization.
    • protobuf — A fork of protobuf_for_node with an npm package.
  • reified — JS Binary Data API. Structs, arrays, bitfields, and data. Reify and Reference like nobody's business.
  • strtok — A streaming tokenizer library for binary data
  • struct — Parse/format binary data in buffers.

Feed and RDF parsers

  • feed-tables — a lightweight parser for Google Spreadsheet tables available as cells or list atom feeds.
  • feedme.js — RSS/Atom/JSON feed parser with streaming capabilities.
  • feedparser — RSS, Atom, and RDF feed parsing in Node.js
  • NodePie — Simple RSS/Atom parser for Node.JS
  • rdf2json — A simple RDF/XML to JSON converter
  • VIE — RDFa parsing in Node.js

.INI file parsers

  • iniparser — a simple .ini parser
  • inireader — .ini file parser
  • node-ini — A simple .ini config parser that supports sections, comments, arrays, and objects.

Parser generators

  • 2kenizer — It streams, it caches and it's simple, it matches RegExp's and strings.
  • bnf — BNF parser, compiler, and interpreter framework.
  • canopy — PEG parser compiler for JavaScript.
  • jison — A parser generator written in JavaScript; similar to Bison for C.
  • jparse — A parser combinator for JavaScript based on Packrat parsers and Parsing expression grammars.
  • JSCC-NODE — The Best and The first parser generator written in JavaScript; Use a regular expression-based lexical analyzer generator and a LALR parser generator for building a stand-alone, working parser.
  • language.js — A fast PEG parser generator with first class errors and reasonable sized output.
  • OMeta JavaScript compiler
  • PanPG — A PEG Packrat Parser Generator for JavaScript.
  • parser — A general purpose parser that feeds on tokens (see tokenizer).
  • PEG.js — Parser Generator for JavaScript.
  • ReParse — A parser combinator library for JavaScript like Haskell's Parsec.
  • tokenizer — A regex-based and streamed tokenizer.

Other parsers

  • apricot — Hpricot inspired clone, JSDom with Sizzle Selector engine and XUI for HTML augmentation
  • argtypes — Function arguments type parser (Allows typed & optional arguments)
  • JsCron — Javascript cron parser, schedule date generator
  • carrier — Evented stream line reader for node.js
  • enhanced-properties — A key-value parser based on Properties with enhanced features.
  • fastcgi-parser — FastCGI protocol parser and Writer
  • glossy — Syslog message parser and producer
  • groan — A PHP session file parser
  • JSML — Appendable sequences of JSON documents
  • lastname — Parse text and search persons by names and surnames. Only at russian for now.
  • mailparser — Parse mime encoded e-mails into structured objects
  • memcache-parser — Memcached binary protocol parser
  • node-office — Parse office documents (odt, doc, docx, ods, xls, etc..) (unoconv, xlhtml)
  • node_spreadsheet — Read xls,xlsx,ods,csv spreadsheets (php based)
  • node-brainfuck — Brainfuck interpreter
  • node-browscap — browscap.ini parser and port of PHP's get_browser function
  • node-formidable — A node.js module for parsing form data, especially file uploads.
  • node-htmlparser — Forgiving HTML Parser in JS for both Node and Browsers
  • node-msgpack — Bindings for MessagePack, space-efficient object serialization library
  • node-netstring — Read and write netstrings
  • node-opds-parser — OPDS Catalog Feed Parser for node.
  • node-opmlparser — OPML parsing in Node.js
  • node-properties-parser — A parser for .properties files written in javascript.
  • node-rfb — Parse the RFB protocol used by VNC
  • node-tldtools — Provides domain enquiry features, whois, TLD token extraction etc.
  • node-useragent — User agent string parser with accurate browser versioning and grouping
  • omcc — A command line tool for Alessandro Warth's OMetaJS
  • ometa-js , ometajs — A JavaScript OMeta implementation
  • parser_email — Simple multi type email parser
  • pcap-parser — Packet capture (pcap) file parser written in pure javascript
  • pdc — A pandoc wrapper for node.
  • picksy — Extracts the relevant text from a html article page
  • Platform.js — A platform detection and user agent parsing library that works on nearly all JavaScript platforms
  • properties — A Java .properties file parser ported to node.js.
  • querystring.node.js — Robust query string parsing for node.
  • ret.js — A regexp tokenizer.
  • semver — Parser used by npm for version numbers.
  • service-parser — /etc/services file parser
  • strscan — Simple string tokenizer for lexical scanning operations
  • tap — Tools for the Test Anything Protocol
  • tldextract — Extract domain, subdomain and tld from a url.
  • UglifyJS — JavaScript parser and compressor/beautifier

File system

  • buffered-reader — Fully configurable buffered reader.
  • buffered-writer — Fully configurable buffered writer.
  • diskspace.js — A simple module to check disk space usages in bytes.
  • mass_hfs — height level file system, can simultaneously operate of the directories and files, multi-stage creating folders……
  • file-utils — File and directory utilities. Object representation of file and directory path names.
  • fs-extra — Patches the Node.js fs object with a couple of extra methods (a method to copy a file and a method to delete a directory recursively), both sync and async versions.
  • fstream — High-level objects like FS streams, but with stat on them, and supporting directories and symbolic links, as well as normal files. Also, you can use this to set the stats on a file, even if you don't change its contents, or to create a symlink, etc.
  • fsutil and fsautil — Synchronous and asynchronous file system utilities for Node.js.
  • hdfs — JNI-implemented HDFS client allowing node.js applications to natively interoperate with the Hadoop FileSystem.
  • line-reader — Asynchronous line-by-line file reader.
  • meta-fs — Patches the Node.js fs object with methods that find files, delete directory trees, create nested directories, make symlinks, copy files and directories.
  • pathspec — Shell- and .gitignore/.npmignore-style wildcards and file lists
  • wrench — Recursive operations (create directory, delete directory, read contents, chmod, chown, deep copy). Line-by-line reader. Asynchronous read of directories contents.
  • qfs - File I/O in jQuery way
  • scopedfs — A convenient API to build and access file system subtrees, particularly in tests; provides a version of every ‘fs’ module function scoped to the given root or, optionally, to a new temporary directory; also adds a bunch of convenience methods.

Debugging / console utilities

Debugging and profiling

  • autolint — Autolint watches your files for jslint/jshint-errors.
  • debug — node core style debugging for your libraries and applications
  • Eclipse debugger plugin — Using Eclipse as Node Applications Debugger
  • eyes.js — A better, customizable value inspector for node.js
  • http-console — A simple & intuitive HTTP console for testing APIs.
  • jsdev — a wrapper for Douglas's JSDev
  • monitor — Runtime monitoring for node.js applications - npm install monitor
  • ndb — traditional command line debugger (like gdb, ruby-debug, etc)
  • node_debug — HTTP based console and object explorer
  • node-codein — browser based console and object explorer (stand-alone, no dependencies)
  • node-custom-debug — debugger on custom port on the fly, good addition for node-inspector to inspect many instances on the one server with ease
  • node-inspector — browser based node debugger
  • Node-JavaScript-Preprocessor — Preprocessor for JavaScript
  • node-profiler — access the V8 profiler from node.js
  • node-webkit-agent — WebKit devtools agent that leverages remote debugging and profiling of nodejs applications using built-in webkit devtools front-end.
  • nodetime — Performance profiler and monitor for Node.js applications
  • profilejs — profiling middleware for use with node-inspector (profiles Express handlers)
  • Replica — Repl to exec JavaScript code on browser
  • spine — Dynamic runtime monitoring for node.js applications inspired by lorenwest's monitor.
  • strack — bug tracking/tickets system
  • UltraREPL — Replaces Node's built-in REPL with customizable keybindings, a significantly enhanced inspector with hidden/builtin/depth toggles, simultaneous independent V8 contexts, syntax highlighting, and a full-fledged plug-in system including CoffeeScript contexts, SpiderMonkey contexts, and more.
  • v8-profiler — v8 profiler bindings with node-inspector integration
  • webrepl — Serve a repl for a node process via a simple web ui
  • jecho — Remote debugging command line client/server. Like Weinre, but without the GUI

Logging and dumping

  • ain — Brain-free syslog logging
  • Caterpillar — Caterpillar is an awesome, simple, intuitive console logger for node.js. It supports grouping of messages, filtering log levels, colors, times, modules, custom formatters and custom transports.
  • cfdump.js — a more visually inspiring way to dump your objects to a browser
  • console-plus — console logging with filenames and line numbers
  • flume-rpc — A flume-compatible (RPC) logging source and sink
  • gelf-node - gelf-node is a full implementation for sending messages in GELF (Graylog Extended Log Format) from node.js to Graylog
  • hexy.js — hex pretty printing like xxd
  • inspect — hierarchical object inspection displaying ancestry, properties, methods, and accessors in great detail.
  • jog — JSON-based logger with multiple stores, namespacing, CLI and more
  • log.js — light-weight logger that works with any writable stream, also supports a streaming parser for reading the log files generated
  • log4js-node — a port of log4js framework for node.js
  • logging — Super sexy color console logging.
  • logly — A minimal logging utility to support verbose and debug modes with basic colors
  • logule — A sexy portable logging utility using colors
  • nlogger — Logging lib that can print also module names and line numbers, optionally in color
  • node-logentries — A winston-compatible wrapper library for the logentries.com service
  • node-logging — Simple colorized logging for Node.js with request logger Express middleware
  • node-streamlogger — Extensively customizable logging, with support for rotation
  • node-tick — v8.log processor
  • NodeLog — Logging library for Node.js based on the java.util.logging library.
  • onelog - Logging consolidation library
  • nogg — Simple file/stdio logging for node.js
  • spruce — configurable node.js logging module (Note: 404 error on link.)
  • stdjson — Minimally logging JSON to stdout and stderr
  • tracer — A powerful and customizable logging library for node.js. support color console with timestamp, line number, method name, file name and call stack. you can set transport to file, stream, database(ex: mongodb and clouddb, simpledb). keywords: log, logger, trace
  • underscore.logger — Cross-browser and Node.js empowered logging that can be used as an Underscore mixin.
  • Windows Event Log Js — native Node.js module to log messages to the Microsoft Windows EventLog
  • Winston — A multi-transport async logging library for node.js
  • PuperGrep - Real-time web view for your logs with hightlighting, grep and more.
  • stdlog - A Node.js log utility that logs messages to stderr by default.
  • blammo - A powerful NodeJS logger loosely based on Logback.

Console colors and other ANSI codes

  • ansi pansi — basic ANSI formatting, foreground and background colours for use with CLI
  • ansi-font — ANSI font styling (background and foreground colours)
  • ansi.js — advanced ANSI formatting tool for Node.js
  • ansidiff — a small node.js library for ANSI colored text diffs
  • ANSIdom — a quick and dirty DOM implementation in ANSI escape codes
  • ansimator — simple animations onto the terminal with ANSI codes
  • ANSInception — Colorful exception handler for Node.js with CoffeeScript support and improved nodemon/supervisor compatibility
  • ansiparse — parses text with ANSI codes to an array of JavaScript objects
  • ansispan — changes ANSI color codes to HTML <span> elements with CSS color styles
  • charm — use ansi terminal characters to write colors and cursor positions
  • cli-chart — creates pseudographic charts in Node console with ANSI-coloured blocks
  • cli-color — colors and formatting for the console
  • colored.js — Colorize terminal output.
  • colorize — Markup tool which uses English words to set text colours with ANSI codes.
  • colors.js — get colors in your node.js console like what
  • colours.js — Give your CLI programs some colours! (Does not support background colour manipulation.)
  • consolelog.js — stylized console logging for node.js
  • irc-colors.js — Color and formatting for irc bots made easy
  • kahve-ansi — easy-mode insertion of ANSI colour codes
  • node-cli — cli.clear().move(20,20).color('green').write('Node-cli').down(1).back(7).color('yellow').write('Rocks!')
  • prettyjson — Package for formatting JSON data in a coloured YAML-style, perfect for CLI output.
  • String ANSI — extends the String prototype with the function color, which inserts ANSI color codes in place of color string names.
  • term-css -- style terminal output using CSS

Other console tools

  • easy-table — Nice and simple text table for the cli
  • node-prompt — Prompt the user for questions in cli!
  • Shell — Nice looking shell applications with pluggable middlewares

Compression

Gzip and zlib

  • connect-gzip — Gzip middleware for Connect. Contains middleware for gzipping and serving static files as well as gzipping responses dynamically.
  • gzip — simple compression using default linux "gzip" utility
  • node-compress — streaming compression / gzip library
  • node-gzbz2 — streaming compression / gzip / bzip2 library for node.js, originally forked from waveto's
  • node-zlib-sync — rfc1950/rfc1951/rfc1952 compress/uncompress (C++ around libzlib)
  • node-zlibstream — Streaming zlib library using zlib

Zip

  • node-zip — zip/unzip support ported to Node.js from JSZip (pure JavaScript, no C++)
  • node-zipfile — inspect and uncompress zipfile archives (C++ around libzip)
  • zip — .zip file unpacker (pure JavaScript, no C++)

Other compression and minification

  • crsh — merge and minify groups of js files and recompile when changes occur
  • lzma — A standalone JavaScript implementation of the Lempel-Ziv-Markov chain (LZMA) compression algorithm
  • lzw-async — Asynchronous Javascript implementation of Lempel-Ziv-Welch (LZW) compression algorithm
  • node-compress-buffer — single-step Buffer compression library on top of zlib
  • node-lzf - lzf compression library (C++ around liblzf)
  • node-snappy — compression using Google's snappy library.

Sound

  • play - play sound files from node.js to your speakers
  • node-sound — The best sound library for Node (Only for MacOSX)
  • node-mpg123 - JS wrapper around mpg123.

Chat

  • chat.io — A simple chat solution build on socket.io

Graphics

  • alleup - Flexible way to resize and upload images to Amazon S3 or file system storages
  • drawback — Seamless way to render 2D drawings on the client side using HTML5 technologies with a server-side backend.
  • EasyImage — User-friendly module for common image editing requirements. Requires ImageMagick.
  • exiv2node — Extension that provides asynchronous support for reading & writing image metadata via Exiv2.
  • Face.js — Node.js module for detecting faces in images
  • gm — GraphicsMagick for node
  • magician — Image manipulation for Node.js using ImageMagick.
  • magickal-node — GraphicsMagick wrapper for node.js
  • node-exif — Library to extract Exif metadata from images
  • node-gd — GD graphic library bindings
  • node-gif — Convert an RGB or RGBA buffer to GIF fast
  • node-graphviz — GraphViz for node
  • node-image — Unifies node-png, node-gif, node-jpeg
  • node-imagemagick — ImageMagick module
  • node-imager - Easy way to resize, crop and upload images (with different presets) to Rackspace cloudfiles and Amazon S3.
  • node-jpeg — Convert an RGBA or RGB buffer to JPEG fast
  • node-magick — rewrite of GraphicsMagick wrapper magickal-node fixing some issues
  • node-ogl — OpenGL bindings
  • node-opencv — Node.js bindings for OpenCV. Originally forked from peterbraden/node-opencv
  • opencv-node - Node.js bindings for OpenCV. Supports most of the OpenCV 2.42 API, including video capture.
  • node-pango-view — print text with pango to temporary png image, then merge it with ImageMagick.
  • node-png — Convert an RGB or RGBA buffer to PNG fast
  • node-qr — QR code generator for node
  • node-webgl — WebGL emulation
  • node-wkhtml — Convert HTML to PDF or PNG using the Webkit Rendering Engine.
  • pdfkit — A powerful PDF generation library for Node
  • squeeze — Mince and convert images on the cloud using UploadJuicer.

Canvas

  • node-canvas — High performance canvas implementation backed by the phenomenal Cairo graphics library
  • node-o3-canvas — Fast HTML5 Canvas and image processing implementation based on AGG
  • palette — Image color palette extraction library built with node-canvas

Building desktop GUI applications

  • AppJS — SDK on top of Node to build desktop apps (GUI windows) with HTML/CSS/JS.
  • node-webkit — SDK for running Node modules (and other Node code) inside WebKit (browser) windows, to build desktop apps with HTML/CSS/JS.

Clipboard

  • clipboard — Easy to use utility for reading and writing to the system clipboard.
  • node-copy-paste — A command line utility that allows read/write (i.e copy/paste) access to the system clipboard.

Maps

  • node-mapnik — Mapnik bindings for high performance rendering of map tiles.
  • node-mapserver — mapserver bindings for rendering mapserver MAP files via node

Video

  • ffmpeg-node — Node.js driver for ffmpeg library
  • ffmpeg2theora — Batch encoding with ffmpeg2theora
  • navcodec — Node bindings for libavcodec (ffmpeg).
  • node-fluent-ffmpeg — Fluent API for ffmpeg (including streaming, thumbnail-generation and custom presets)
  • node-handbrake — HandBrakeCLI wrapper to encode an entire folder of videos
  • node-video — Create Theora/OGG videos from RGB(A) buffers (and stream them via tag)
  • ytdl — Pure Javascript youtube video downloader.
  • youtube-dl — youtube-dl driver for node

Payment Gateways

  • braintree — library for integrating with Braintree
  • dwolla — library for integrating with Dwolla
  • node-fortumo — bindings for Fortumo SMS payment API
  • node-stripe — library for integrating with Stripe
  • nodewm — Webmoney signing module for NodeJs
  • paynode - library for integrating with various payment gateways
  • paypal-ipn — library for verifying paypal IPN messages

API clients

  • ADAuthFTW - Simple Active Directory authentication (Windows Only)
  • airship — an Urban Airship API wrapper
  • akismet-js — A client for the Akismet spam detection API
  • alleup - Flexible way to resize and upload images to Amazon S3 or file system storages
  • authom - A dependency-free mutli-service authentication tool
  • aws-lib — An extensible library for Amazon Web Services including EC2, SimpleDB and the Product Advertising API
  • aws-snsclient — A client for handling Amazon AWS SNS endpoints
  • aws2js — Amazon Web Services APIs client implementation for node.js. Simple to use and extend.
  • awssum — NodeJS modules for talking to lots of Web Service APIs
  • azure - A library for accessing Windows Azure services including Tables, Blobs, Queues and Service Bus.
  • calais — Semantically analyze text using the Calais web service
  • cloudfront — Amazon AWS CloudFront client
  • cpanel-lib — Node.js client for the cPanel/WHM API
  • discogs — Discogs API client
  • dribbble-node — A wrapper for the Dribbble API
  • dropbox-node — A wrapper for the Dropbox API
  • ec2 - Light-weight, asynchronous Node.js bindings to the full Amazon EC2 API.
  • ec2metadata — An API wrapper for the AWS EC2 metadata.
  • evented-twitter — asynchronous twitter client, supports streaming api
  • facebook-api — offers high level and low level calls against the facebook graph API
  • facebook-js — Easy peasy facebook client for connect.
  • fbgraph — Sexay Facebook graph api
  • fitbit-js — Simple FitBit API wrapper
  • flickr-reflection — A flickr client that uses their reflection API (supports auth)
  • flickrnode — A library to enable use of the flickr api (not as complete as node-flickr, but supports auth)
  • forrst — Simple wrapper for the Forrst.com API.
  • gdata-js — Simple Google Data API OAuth 2.0 wrapper
  • geo — A very basic, but simple, geocode library, currently using Google Geocode API (v3)
  • gist — A gist creator. Create GISTs and use the generated URI.
  • gnip — A simple library that allows you to connect to Gnip Twitter Power Track and manage rules easily.
  • gravatar — Well tested Node.JS Gravatar URL generator
  • gumroad — API client for Gumroad. 100% coverage of available methods.
  • hipchat-js — Simple HipChat API wrapper
  • hoover — An Amazon Product Advertising API wrapper
  • instagram-node-lib — Library for easy interaction with the Instagram API
  • janrain-api — Module for interfacing with Janrain Engage API
  • klout-js — Simple Klout API wrapper
  • lastfm-node — Read and write to users' recent plays on Last.fm
  • libravatar — Module for generating Libravatar avatar URLs.
  • linkedin-js — Easy peasy linkedin client for connect.
  • madmimi-node — Client library for the MadMimi email api http://www.madmimi.com.
  • mixpanel-node — A simple Mixpanel API library for server-side analytics.
  • mturk — Amazon Mechanical Turk API wrapper https://github.com/expensecat/mturk.
  • n-vimeo — Vimeo API (for data) Integration, retrieve info about everything (video,user,activity) with ease, an extension of vimeo-client.
  • Nexmo Node API — A module for sending and receiving SMS messages via Nexmo REST API.
  • node-4sq — Node.js client for the Foursquare API.
  • node-500px — A wrapper for the http://www.500px.com API.
  • node-apn — A library to send messages using the Apple Push Notification Service.
  • node-armory — A simple wrapper around Blizzard's REST API for World of Warcraft.
  • node-beaconpush — Client for the Beaconpush REST API. A real-time push service for browsers supporting WebSockets and Comet.
  • node-bitly — A bit.ly API library for node.js - provides URL shortening/expanding. Features full API.
  • node-bot — Fast and Real-time extraction of web pages information using node-dom (html,text,etc) based on given criterias
  • node-c2dm — A library to send messages using the Android Cloud to Device Messaging (C2DM) service.
  • node-cloudfiles — A client implementation for Rackspace CloudFiles in node.js
  • node-cloudservers — A client implementation for Rackspace CloudServers in node.js
  • node-dropbox — Node.js client for the Dropbox API
  • node-instapics — Node.js client for the Instagram API.
  • node-flattr — The flattr API client.
  • node-foursquare — A wrapper for the Foursquare v2 API.
  • node-gadgets — Real-time extraction from web pages of HTML gadgets and associated properties using node-dom based on given criterias
  • node-gdata — A generic Google Data API client library
  • node-gisty — Node.js client for the GitHub gist API v3.
  • node-github — A wrapper for the GitHub API
  • node-gitteh — Async, stable, feature-complete bindings for the libgit2 library.
  • node-googleanalytics — Google Analytics GData export library
  • node-googlemaps — A wrapper for the Google Maps API
  • node-googleSearch — Implementation of Google Search Ajax API using node-dom
  • node-gravatar — Node.js Gravatar URL generator, can be used with Node.js blogging frameworks
  • node-klout — Extremely reliable Node.js Klout API Wrapper
  • node-kraken — Plug into the power and speed of Kraken.io Image Optimizer
  • node-loggly --A client implementation for Loggly in node.js
  • node-mailchimp — A wrapper for the MailChimp API, MailChimp Export API and MailChimp Webhooks
  • node-mailgun — Client library for MailGun
  • node-mixpanel-api — A simple client for the Mixpanel Data API (not event tracking! see above)
  • node-neoip — binding for neoip
  • node-notifo — Real-time notifications pushed to your mobile phone (and more).
  • node-ocr — ABBYY API wrapper.
  • node-ostatus — An implementation of the OStatus protocol (Webfinger, Push, Hcard, Salmon, etc.)
  • node-ovh — A helper library for OVH.com web services
  • node-pdfcrowd — A wrapper for the Pdfcrowd API. It lets you convert web pages and raw HTML code to PDF.
  • node-posterous — Library for the Posterous API
  • node-prowl — A module that allows you to send push notifications to your iPhone through the Prowl API
  • node-rapleaf — RapLeaf API client
  • node-sendgrid — Sendgrid SMTP API headers library
  • node-spore — Node.js implementation of spore Generate api client with a json file.
  • node-sunlightapi — A client library for the Sunlight Labs Congress API
  • node-taobao — A client library for taobao.com api
  • node-twilio — A helper library for the Twilio API
  • node-twitter — Asynchronous Twitter REST/stream/search client for node.js
  • node-untappd — Library for accessing the Untappd APIs.
  • node-vk — vkontakte.ru and vk.com social network api wrapper for mobile and desktop applications.
  • node-wikimapia — Node.js wrapper for the Wikimapia API
  • node-yelp — A wrapper for the Yelp's APIv2. Let's you search for businesses and get specific business information.
  • nodefm — So far just a util for consuming last.fm recent tracks history for a user
  • nodegit — Asynchronous native Node.js libgit2 bindings with a convenient api
  • nodestagram — Instagram client for node
  • nodestalker — A beanstalkd client for node
  • nodevore — Convore API wrapper
  • openstack-storage — A module for accessing Openstack Storage (Swift)
  • pingdom — A module for accessing the Pingdom JSON API
  • postageapp — A module for sending emails through the PostageApp JSON API
  • rackit — A simple library for managing a large number of files on Rackspace Cloud Files (CloudFiles)
  • ranger — A simple library which wraps Campfire's API
  • rottentomatoes - Simple interface for the Rotten Tomatoes API
  • sailthru-client — A wrapper for Sailthru API
  • sms — Aimed at whole SGIP/SMPP nodes support for SMS system, now focused on SP function.
  • SMSified-node — A module for sending and receiving SMS messages (text messages) with the SMSified API.
  • spotify — Spotify api wrapper. Metadata lookup and search. Works with Spotify and http uris
  • supervisord - Library for supervisord
  • tuiter - Library for Twitter Search, REST and Streaming API
  • tropo-webapi-node — A library for building multi-channel communication apps with the Tropo WebAPI.
  • tumblr — A wrapper for Tumblr's API v2
  • tumblrrr — A wrapper for Tumblr's API
  • tweetstream — Stream like API for twitter's HTTP streaming interface.
  • TwitScript — A port of Twython to Node.js (Twitter API Library)
  • twitter-js — Easy peasy twitter client for connect.
  • twitter-search — Twitter API Search w/ search result pagination, returning up to 1500 queried tweets with RegEx search, kSorts, Klout scoring and filters
  • VIE — Apache Stanbol and DBpedia API client for Node.js
  • vimeo-client — Vimeo API client for Node.js
  • virustotal.js — VirusTotal API client for node.js
  • waz-storage-js — A simple implementation of Windows Azure Storage API for Node.js
  • webmetrics — A module for accessing the Webmetrics JSON API
  • yammer-js — Simple Yammer API wrapper
  • fb-js - Facebook api done right.
  • oss - OSS is a node.js SDK and Command-Line Tool for Aliyun OSS

Control flow / Async goodies

Libraries

  • $N — Simple control flow with pretty syntax.
  • async-mini — Minimalistic async lib implementing only .parallel() and series(). Simple code, predictable behavior, server and browser.
  • async.js — Async chaining and file system utilities. Async.js is to node's fs module, what jQuery is to the DOM.
  • async — Comprehensive async map/reduce and control flow (parallel, series, waterfall, auto...) module that works in node and the browser
  • backbone-callbacks — Node.js style callbacks for Backbone.js asynchronous methods
  • begin — Control flow library for node.js and CoffeeScript
  • chainsaw — Build chainable fluent interfaces the easy way in node.js
  • channels — Event channels for node.js
  • cloudd — Job manager, runs set of tasks defined using a DAG definition
  • deferred — Asynchronous control-flow with deferred and promises
  • each — Chained and parallel async iterator in one elegant function
  • EventProxy.js — An implementation of task/event based asynchronous pattern. Use events to avoid dirty callbacks.
  • first — A tiny control-flow library.
  • flow-js — Continuation-esque contruct for expressing multi-step asynchronous logic
  • flowless — Less but better control-flow library.
  • funk — Asynchronous parallel functions made funky!
  • futures - Asynchronous Method Queueing, Futures, Promises, Subscriptions, and other async goodies
  • gate — An utility to await multiple asynchronous calls
  • groupie — A simple control flow library for executing multiple functions as a group or in a chain, calling back when complete.
  • Ignite — An easy-to-use async programming framework inspired by UML2 state machines.
  • jam — Monadic continuation/callbacks/async helper.
  • JobManager — A really simple tool that helps you manage multiple asynchronous tasks.
  • jscex-jquery — Jscex adapter to jQuery.Deferred API, with $.async/$await support
  • LAEH2 — Lightweight Asynchronous Error Handling v2. Wrap your asynchronous functions in an intelligent try/catch. Optional stack trace minification with async support, e.g.: unexpected thing < ./ex1.js(9) << ./ex1.js(7 < 13).
  • locker (server) and node-locker (client) — lock server and client for distributed systems with waiting and execution timeouts.
  • miniqueue — A very simple in-memory queue for easy sequential processing
  • narrow — Shrinks a given callback parallel execution concurrency in a limited number of threads, receiving a big bunch of data (array of tasks)
  • nestableflow — Asynchronous nestable flow-control (serial, parallel, repeat, wait, function) module for Node.js, RequireJS, and browser.
  • neuron — The simplest possible event driven job manager, FIFO queue, and "task based cache" in node.js
  • node-async — Executes a number of functions and returns the results of each function, when all are complete, for processing. Based on Narrow.
  • node-block — An async control-flow library. Easily error handling.
  • node-chain — Simple call chaining library for node.js
  • node-continuables — A library making dealing with asynchronous code easier
  • node-cron — Schedule callbacks with cron syntax
  • node-crontab — Allows reading, manipulating, and writing user crontabs from node.js
  • node-fnqueue — Functions chain utility
  • node-inflow — A next generation async control-flow library, with a shared object for called functions and debugging made easy.
  • node-parallel — Create tasks in node.js that run in parallel, or sequences that run tasks one after another.
  • node-promise — Robust promises for node.js, includes promise utilities and promise-based I/O library
  • node.flow — A deadly simple flow control package for node.js
  • noflo — Flow-Based Programming system for Node.js
  • nue — An async control-flow library suited for node.js
  • observer — An alternative observer implementation, for both ss&cs.
  • pauseable — Easily pause and resume event emitters, timeouts, and intervals.
  • pipette — A collection of pipe / stream utility classes.
  • poolr — A lightweight resource pooling/serialization library
  • promise — A Continuation handler (monad) with a condition system for errors
  • q — Q is a tool for making and composing asynchronous promises in JavaScript.
  • QBox — Quick Controller flow for NodeJS
  • read-files — Asynchronously read a bunch of files and give a callback when reading is complete.
  • Rubberduck — Punch JavaScript objects and receive events before and after a function executes.
  • statechart — An implementation of Statecharts as described in Practical Statecharts in C/C++: Quantum Programming for Embedded Systems by Miro Samek.
  • SCION — An implementation of SCXML/Statecharts in JavaScript.
  • seq — Chainable asynchronous control flow for node.js with sequential and parallel primitives and pipeline-style error handling
  • Signals — Custom Event/Messaging system which supports advanced features, doesn't rely on strings for the event publishing/subscribing and favor composition over inheritance.
  • simple-schedule — Simple scheduler for dispatching a number of batch tasks at defined intervals
  • Slide — A control flow library that fits in a slide presentation
  • soda.js — Asynchonous JavaScript module loader for client-side and Node.js
  • Step — Tool for grouping and chaining asynchronous callbacks, based on flow-js
  • stepc — A CoffeeScript-safe version of creationix' step
  • streamify — Streamify helps you easily provide a streaming interface for your code.
  • taskman — A task management library for managing (possibly) asynchronous tasks by declaring task dependencies.
  • timequeue — A queue with custom concurrency and time limit.
  • TwoStep — An async control-flow library that makes stepping through logic easy. The spiritual successor of Step with better error handling and finer flow control.
  • when — A lightweight CommonJS Promises/A and when() implementation. It also provides several other useful Promise-related concepts, such as joining and chaining, and has a robust unit test suite.
  • zo.js — Async-friendly versions of the usual list processing functions: map, select, reduce and friends.

Fibers

  • asyncblock — Simple and powerful interface to fibers
  • fiberize — Node API wrapper for use with fibers.
  • fibers-promise — Small yet powerful promises based on fibers.
  • fibers — The closest thing to a thread you'll find in JavaScript
  • sync — Write simple and readable synchronous code in nodejs using fibers (based on node-fibers)

Other Language Extensions

  • Cinch — Write async code in sync form.
  • Jscex — Transforms sync code into monadic, async code as the async support in F# and Scala.
  • qjs — transforms synchronous looking code that uses Q promises into asynchronous code.
  • sjs — Asynchronous JavaScript for synchronous people
  • streamline.js — Tool that transforms synchronous code into asynchronous code with callbacks.
  • syncasync.js — syncasync.js allows you to run synchronous functions asynchronously, and asynchronous functions synchronously.
  • tamejs — Library by OK Cupid for flattening out async code.

I18n and L10n modules

  • cld — A straight port of the CLD (Compact Language Detector) library embedded in Google's Chromium browser.
  • connect-i18n — Middleware for connect to handle i18n.
  • dialect-http — http client to manage your dialect translations.
  • dialect — Translations for nodejs.
  • i18n-node — Exports common __(), __n() syntax. Stores JSON objects dynamically on code-change.
  • i18next — full-featured (plurals, vars, context, nesting,...), express middleware, template support, clientside usage/sharing
  • inflect — A port of the Rails / ActiveSupport inflector to JavaScript (node.js and browser compatible).
  • Lingo — Inflection, transformation and more
  • lingua — A i18n middleware for the Express.js framework.
  • localize — A localization module with Date support and simple Express integration.
  • node-date-diff — Calculates date differences and allows to format it nicely to your language (Eg. In one hour)
  • node-gettext — Use Gettext .MO files with Node.js.
  • node-i18n — node-i18n is a minimalistic internationalization module with templating
  • node-language-detect — NodeJS language detection library using n-gram (which can identify up to 52 human languages)
  • resource-bundle — Internationalization tool that provides locale-specific resources. Compatible with connect/express.js.
  • translate.js — translate text from one language to another on node.js and the browser. 30+ languages supported, simple as cake.
  • unidecode — ASCII transliterations of Unicode text

Boilerplates

  • Alice — Killer Node.js + Mocha Boilerplate for creating NPM packages for both Javascript and Coffee-Script coders. (: seems a advertisement)
  • infigo-node-boilerplate — nodejs boilerplate built upon Express, db-mysql/db-drizzle/Mongoose and includes user authentication and group+role authorization system.
  • Lemmy — 49% Motherfucker | 51% Son of a Bitch Node.js + Express + Mocha flexible project boilerplate for Javascript/Coffee-Script coders.
  • node-backbone — Sample project for a Node/Backbone/HTML5 application optimized separately for desktop browsers (web), generic mobile platforms using jQuery Mobile (jquerymobile) and iPhone (iphone). Uses Express, Socket.io, Mongoose/MongoDB, Redis.io (for sessions) and Mocha (for testing).
  • node-boilerplate — Everything you need to get started on a Node.js website with express and socket.IO
  • NodeBase — A node base class for JavaScript and CoffeeScript (logging, options, defaults and EventEmitter)
  • npm-boilerplate — Boilerplate for creating NPM packages
  • Skeleton — Skeleton is a CLI module to bootstrap a Node/Express project with a skeleton template via any git repository, with an included default repo.
  • transsiberian — [outdated] nodejs boilerplate built upon Express and Mongolia
  • node-package-boilerplate - boilerplate files and dirs for a plain node.js project. more intended for starting node packages.

Continuous Integration Tools

  • Concrete — Simple continuous integration server written with NodeJS and CoffeeScript
  • Jenkins API — An API written in Node for Jenkins, allowing you to trigger jobs, delete jobs, copy jobs, etc.
  • nestor — Jenkins (or Hudson) command-line interface in Node.js

DDD, CQRS, EventSourcing

  • [cqrsnode] (https://github.com/brighthas/cqrsnode) — Domain development , DDD-CQRS framework for node.js.
  • [cloudjs] (https://github.com/digitalwm/cloudjs) — provides a network distributed event system and a
  • node-cqrs-domain — Node-cqrs-domain is a node.js module based on nodeEventStore that. It can be very useful as domain component if you work with (d)ddd, cqrs, eventdenormalizer, host, etc.
  • node-cqrs-eventdenormalizer — Node-cqrs-eventdenormalizer is a node.js module that implements the cqrs pattern. It can be very useful as eventdenormalizer component if you work with (d)ddd, cqrs, domain, host, etc.
  • node-cqrs — node.js cqrs implementation. CouchDb repository embedded, others can be plugged in. Contains basic implementation of denormalized view builder with storing data snapshots.
  • node-cqs — Node-cqs is a node.js module that implements the cqrs pattern without eventsourcing. It can be very useful as domain and eventdenormalizer component if you work with (d)ddd, cqrs, host, etc.
  • node-queue — Node-queue is a node.js module for multiple databases. It can be very useful if you work with (d)ddd, cqrs, eventsourcing, commands and events, etc.
  • node-viewmodel — Node-viewmodel is a node.js module for multiple databases. It can be very useful if you work with (d)ddd, cqrs, eventdenormalizer, host, etc.
  • nodeEventedCommand — provides simple command/event handling for evented systems like cqrs
  • nodeEventStore — EventStore (Events and Snapshots) supporting MongoDb, CouchDb, Redis
  • rule-validator — Rule-validator is a javascript module based on amanda. And works for node.js and in the browser. It can be very useful if you work with (d)ddd, cqrs, eventsourcing, domain, commands and events, etc. realtime balancing for live objects
  • cqrs-bus — cqrs-bus is a message queue for sending and receiving commands, events & co.
  • cqrs-commands — cqrs-commands is a middleware for Connect / Express to create and manage commands.
  • cqrs-events — cqrs-events creates and manages events.
  • cqrs-eventstore — cqrs-eventstore stores and manages events in a MongoDB database.
  • cqrs-handlers — cqrs-handlers is a module to dynamically handle CQRS commands.
  • cqrs-repository — cqrs-repository handles loading and committing aggregates.
  • cqrs sample - a simple to understand sample how to approach (D)DDD / CQRS in node.js, plus short overview / tips for existing frameworks after understanding principles.

JavaScript threads

  • Threads A GoGo — Run cpu-bound JavaScript tasks non-blockingly in background kernel threads. With EventEmitter and continuation passing style APIs.

Monitoring and Alerting

  • Nervous — Pluggable monitoring system with support for Graphite.
  • Response — Pluggable alerting system and Graphite proxy.
  • zabbix-agent-client — getting data from zabbix_agent servers.

Functional Programming

  • Underscore — Utility belt for Javascript. Adds iterators and much more.
  • FJS — Functional Javascript. Currying, point-free composition.

Physics

Devices, Protocols, Stacks

  • devicestack — This module helps you to represent a device and its protocol.

Other

  • bigdecimal — Helps circumventing the problem of "0.1 + 0.2 = 0.30000000000000004".
  • BinaryJS — Node binary websocket streaming made easy
  • append — Append properties from one object to another.
  • attache.js — Very basic AOP implementation
  • audience-meter — A simple audience meter based on Socket.IO, perfect for live events tracking
  • behaviors — A simple way to check a module's exports, useful for 3rd party plugins and extensions
  • browserify — Browser-side require() for your node modules and npm packages
  • compare.js — Reliable comparison operators for Node.js the way you would expect them to be.
  • crud-bones — CRUD boilerplate/template for Node.JS/Mongo/MySQL/Redis/Express/EJS/Cluster/etc.
  • descriptive-statistics — Descriptive Statistics for JavaScript
  • difflib.js — Text diff library, ported from Python's difflib module
  • Gauss - JavaScript statistics and analytics library
  • GFMS — Github Flavored Markdown Server. Preview your README.md (and other markdown docs) locally before committing it. Uses Github's CSS for faithful representation. Uses ws-rpc to automatically reload your browser upon file changes.
  • highlight.js — Syntax Highlighting (for node.js and browser)
  • Jalali — Gregorian to Jalali Converter
  • jomap — Powerfull object mapper
  • jsbundle — Simple, clean, and automatic bundling of your Node modules and packages for use in the browser.
  • nshell — non-posix shell written with node.js
  • model.js — Simple data validation for both server and browser.
  • node-ast-inlining — A small library that inline and expand function call
  • node-dummy-cache — A simple in memory cache to use with nodejs.
  • node-stem — Bindings to the libstemmer library
  • node-talib — Technical Analysis Library with 100+ indicators and candlestick pattern recognition
  • node-upload-progress — It's a Node.js module to handle upload and upload-progress
  • node.packer — An assets combine and minify tool
  • nova — Node.js libraries ported to the browser. Write once, run everywhere.
  • numpad — Pad numbers with leading zeros to any number of digits
  • oid — Utilities for object identity
  • randexp.js - Create random strings that match a given regular expression.
  • short — NodeJS URL Shortener backed by MongooseJS w/ Complete Example Site
  • sigar — Node Binding to SIGAR (System Information Gatherer And Reporter)
  • sorter — Sort methods: dictionary sort and natural sort
  • toSrc — Turns every JavaScript object or primitive into valid source code that can be evaled again.
  • tty.js - a terminal for your browser
  • twitter-conference - It's a small example how to create twitter online conference with Node.js, Twitter Streaming API and Websockets.
  • version — NodeJS package.json version number fetcher
  • value - Convenient high-performance type-checking for JavaScript
  • yui — YUI available in Node.js, (extra docs)
  • strformat - Node.js string formatting the way you expect it to work.
  • parambulator - A simple way to generate nice error messages for named parameters.
  • subst - Substitutes placeholders in strings, arrays and objects
  • urlmatch - URL host/port/path matching (kind of like fnmatch)
  • node-eibd - eibd client for eib/knx daemon
  • typed - Static typing library
Add a custom footer
Add a custom sidebar
Clone this wiki locally