diff --git a/demo/README b/demo/README
new file mode 100644
index 0000000..4ee4cf8
--- /dev/null
+++ b/demo/README
@@ -0,0 +1,5 @@
+The programs here are intended to demonstrate how to use the nanomsg API.  
+The intention is that you can use these programs (or parts thereof) in
+your own code.
+
+We welcome further contributions here.
diff --git a/demo/async_demo.c b/demo/async_demo.c
new file mode 100644
index 0000000..b82a2aa
--- /dev/null
+++ b/demo/async_demo.c
@@ -0,0 +1,284 @@
+/*
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom
+    the Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+    IN THE SOFTWARE.
+
+    "nanomsg" is a trademark of Martin Sustrik
+*/
+
+/*  This program serves as an example for how to write an async RPC service,
+    using the RAW request/reply pattern and nn_poll.  The server receives
+    messages and keeps them on a list, replying to them.
+
+    Our demonstration application layer protocol is simple.  The client sends
+    a number of milliseconds to wait before responding.  The server just gives
+    back an empty reply after waiting that long.
+
+    To run this program, start the server as async_demo <url> -s
+    Then connect to it with the client as async_client <url> <msec>.
+
+    For example:
+
+    % ./async_demo tcp://127.0.0.1:5555 -s &
+    % ./async_demo tcp://127.0.0.1:5555 323
+    Request took 324 milliseconds.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <sys/time.h>
+
+#include <nanomsg/nn.h>
+#include <nanomsg/reqrep.h>
+
+/*  MAXJOBS is a limit on the on the number of outstanding requests we
+    can queue.  We will not accept new inbound jobs if we have more than
+    this queued.  The reason for this limit is to prevent a bad client
+    from consuming all server resources with new job requests. */
+
+#define MAXJOBS 100
+
+/*  The server keeps a list of work items, sorted by expiration time,
+    so that we can use this to set the timeout to the correct value for
+    use in poll.  */
+struct work {
+    struct work *next;
+    struct nn_msghdr request;
+    uint64_t expire;
+    void *control;
+};
+
+/*  Return the UNIX time in milliseconds.  You'll need a working
+    gettimeofday(), so this won't work on Windows.  */
+uint64_t milliseconds (void)
+{
+    struct timeval tv;
+    gettimeofday (&tv, NULL);
+    return (((uint64_t)tv.tv_sec * 1000) + ((uint64_t)tv.tv_usec / 1000));
+}
+    
+/*  The server runs forever. */
+int server(const char *url)
+{
+    int fd; 
+    struct work *worklist = NULL;
+    int npending = 0;
+
+    /*  Create the socket. */
+    fd = nn_socket(AF_SP_RAW, NN_REP);
+    if (fd < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        return (-1);
+    }
+
+    /*  Bind to the URL.  This will bind to the address and listen
+        synchronously; new clients will be accepted asynchronously
+        without further action from the calling program. */
+
+    if (nn_bind (fd, url) < 0) {
+        fprintf (stderr, "nn_bind: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);
+    }
+
+    /*  Main processing loop. */
+
+    for (;;) {
+        uint32_t timer;
+        int rc;
+        int timeout;
+        uint64_t now;
+        struct work *work, **srch;
+        uint8_t *body;
+        void *control;
+        struct nn_iovec iov;
+        struct nn_msghdr hdr;
+        struct nn_pollfd pfd[1];
+
+        /*  Figure out if any work requests are finished, and can be
+            responded to. */
+
+        timeout = -1;
+        while ((work = worklist) != NULL) {
+
+            now = milliseconds ();
+            if (work->expire > now) {
+                timeout = (work->expire - now);
+                break;
+            }
+            worklist = work->next;
+            npending--;
+            rc = nn_sendmsg (fd, &work->request, NN_DONTWAIT);
+            if (rc < 0) {
+                fprintf (stderr, "nn_sendmsg: %s\n",
+                    nn_strerror (nn_errno ()));
+                nn_freemsg (work->request.msg_control);
+            }
+            free (work);
+        }
+
+        /*  This check ensures that we don't allow more than a set limit
+            of concurrent jobs to be queued.  This protects us from resource
+            exhaustion by malicious or defective clients. */
+
+        if (npending >= MAXJOBS) {
+            nn_poll (pfd, 0, timeout);
+            continue;
+        }
+
+        pfd[0].fd = fd;
+        pfd[0].events = NN_POLLIN;
+        pfd[0].revents = 0;
+        nn_poll (pfd, 1, timeout);
+
+        if ((pfd[0].revents & NN_POLLIN) == 0) {
+            continue;
+        }
+
+        /*  So there should be a message waiting for us to receive.
+            We handle it by parsing it, creating a work request for it,
+            and adding the work request to the worklist. */
+
+        memset (&hdr, 0, sizeof (hdr));
+        control = NULL;
+        iov.iov_base = &body;
+        iov.iov_len = NN_MSG;
+        hdr.msg_iov = &iov;
+        hdr.msg_iovlen = 1;
+        hdr.msg_control = &control;
+        hdr.msg_controllen = NN_MSG;
+
+        rc = nn_recvmsg (fd, &hdr, 0);
+        if (rc < 0) {
+            /*  Any error here is unexpected. */
+            fprintf (stderr, "nn_recv: %s\n", nn_strerror (nn_errno ()));
+            break;
+        }
+        if (rc != sizeof (uint32_t)) {
+            fprintf (stderr, "nn_recv: wanted %d, but got %d\n",
+                (int) sizeof (uint32_t), rc);
+            nn_freemsg (body);
+            nn_freemsg (control);
+            continue;
+        }
+
+        memcpy (&timer, body, sizeof (timer));
+        nn_freemsg (body);
+
+        work = malloc (sizeof (*work));
+        if (work == NULL) {
+            fprintf (stderr, "malloc: %s\n", strerror (errno));
+            /*  Fatal error -- other programs can try to handle it better. */
+            break;
+        }
+        memset (work, 0, sizeof (*work));
+        work->expire = milliseconds () + ntohl (timer);
+        work->control = control;
+        work->request.msg_iovlen = 0;  /*  No payload data to send. */
+        work->request.msg_iov = NULL;
+        work->request.msg_control = &work->control;
+        work->request.msg_controllen = NN_MSG;
+
+        /*  Insert the work request into the list in order. */
+        srch = &worklist;
+        for (;;) {
+            if ((*srch == NULL) || ((*srch)->expire > work->expire)) {
+                work->next = *srch;
+                *srch = work;
+                npending++;
+                break;
+            }
+            srch = &((*srch)->next);
+        }
+    }
+
+    /*  This may wind up orphaning requests in the queue.   We are going
+        to exit with an error anyway, so don't worry about it. */
+
+    nn_close (fd);
+    return (-1);
+}
+
+/*  The client runs just once, and then returns. */
+int client (const char *url, const char *msecstr)
+{
+    int fd;
+    int rc;
+    char *greeting;
+    uint8_t msg[sizeof (uint32_t)];
+    uint64_t start;
+    uint64_t end;
+    unsigned msec;
+
+    msec = atoi(msecstr);
+
+    fd = nn_socket (AF_SP, NN_REQ);
+    if (fd < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        return (-1);
+    }
+
+    if (nn_connect (fd, url) < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);        
+    }
+
+    msec = htonl(msec);
+    memcpy (msg, &msec, sizeof (msec));
+
+    start = milliseconds ();
+
+    if (nn_send (fd, msg, sizeof (msg), 0) < 0) {
+        fprintf (stderr, "nn_send: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);
+    }
+
+    rc = nn_recv (fd, &msg, sizeof (msg), 0);
+    if (rc < 0) {
+        fprintf (stderr, "nn_recv: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);
+    }
+
+    nn_close (fd);
+
+    end = milliseconds ();
+
+    printf ("Request took %u milliseconds.\n", (uint32_t)(end - start));
+    return (0);
+}
+
+int main (int argc, char **argv)
+{
+    int rc;
+    if (argc < 3) {
+        fprintf (stderr, "Usage: %s <url> [-s|name]\n", argv[0]);
+        exit (EXIT_FAILURE);
+    }
+    if (strcmp (argv[2], "-s") == 0) {
+        rc = server (argv[1]);
+    } else {
+        rc = client (argv[1], argv[2]);
+    }
+    exit (rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+}
diff --git a/demo/pthread_demo.c b/demo/pthread_demo.c
new file mode 100644
index 0000000..b377682
--- /dev/null
+++ b/demo/pthread_demo.c
@@ -0,0 +1,244 @@
+/*
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom
+    the Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+    IN THE SOFTWARE.
+
+    "nanomsg" is a trademark of Martin Sustrik
+*/
+
+/*  This program serves as an example for how to write a threaded RPC service,
+    using the RAW request/reply pattern and pthreads.  Multiple worker threads
+    are spawned on a single socket, and each worker processes jobs in order.
+
+    Our demonstration application layer protocol is simple.  The client sends
+    a number of milliseconds to wait before responding.  The server just gives
+    back an empty reply after waiting that long.
+
+    To run this program, start the server as pthread_demo <url> -s
+    Then connect to it with the client as pthread_client <url> <msec>.
+
+    For example:
+
+    % ./pthread_demo tcp://127.0.0.1:5555 -s &
+    % ./pthread_demo tcp://127.0.0.1:5555 323
+    Request took 324 milliseconds.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <poll.h>
+#include <sys/time.h>
+#include <pthread.h>
+
+#include <nanomsg/nn.h>
+#include <nanomsg/reqrep.h>
+
+/*  MAXWORKERS is a limit on the on the number of workers we will fire
+    off.  Since each worker processes jobs sequentially, this is a limit
+    on the concurrency of the server.  New inbound messages will queue up
+    waiting for a worker to receive them. */
+
+#define MAXWORKERS 100
+
+/*  Return the UNIX time in milliseconds.  You'll need a working
+    gettimeofday(), so this won't work on Windows.  */
+uint64_t milliseconds (void)
+{
+    struct timeval tv;
+    gettimeofday (&tv, NULL);
+    return (((uint64_t)tv.tv_sec * 1000) + ((uint64_t)tv.tv_usec / 1000));
+}
+
+void *worker (void *arg)
+{
+    int fd = (intptr_t)arg; 
+
+    /*  Main processing loop. */
+
+    for (;;) {
+        uint32_t timer;
+        int rc;
+        int timeout;
+        uint8_t *body;
+        void *control;
+        struct nn_iovec iov;
+        struct nn_msghdr hdr;
+
+        memset (&hdr, 0, sizeof (hdr));
+        control = NULL;
+        iov.iov_base = &body;
+        iov.iov_len = NN_MSG;
+        hdr.msg_iov = &iov;
+        hdr.msg_iovlen = 1;
+        hdr.msg_control = &control;
+        hdr.msg_controllen = NN_MSG;
+
+        rc = nn_recvmsg (fd, &hdr, 0);
+        if (rc < 0) {
+            if (nn_errno () == EBADF) {
+                return (NULL);   /* Socket closed by another thread. */
+            }
+            /*  Any error here is unexpected. */
+            fprintf (stderr, "nn_recv: %s\n", nn_strerror (nn_errno ()));
+            break;
+        }
+
+        if (rc != sizeof (uint32_t)) {
+            fprintf (stderr, "nn_recv: wanted %d, but got %d\n",
+                (int) sizeof (uint32_t), rc);
+            nn_freemsg (body);
+            nn_freemsg (control);
+            continue;
+        }
+
+        memcpy (&timer, body, sizeof (timer));
+        nn_freemsg (body);
+
+        /*  Poor mans usleep but in msec. */
+        poll (NULL, 0, ntohl (timer));
+
+        hdr.msg_iov = NULL;
+        hdr.msg_iovlen = 0;
+
+        rc = nn_sendmsg (fd, &hdr, 0);
+        if (rc < 0) {
+            fprintf (stderr, "nn_send: %s\n", nn_strerror (nn_errno ()));
+            nn_freemsg (control);
+        }
+    }
+
+    /*  We got here, so close the file.  That will cause the other threads
+        to shut down too. */
+
+    nn_close (fd);
+    return (NULL);
+}
+/*  The server runs forever. */
+int server(const char *url)
+{
+    int fd; 
+    int i;
+    pthread_t tids [MAXWORKERS];
+    int rc;
+
+    /*  Create the socket. */
+    fd = nn_socket(AF_SP_RAW, NN_REP);
+    if (fd < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        return (-1);
+    }
+
+    /*  Bind to the URL.  This will bind to the address and listen
+        synchronously; new clients will be accepted asynchronously
+        without further action from the calling program. */
+
+    if (nn_bind (fd, url) < 0) {
+        fprintf (stderr, "nn_bind: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);
+    }
+
+    memset (tids, 0, sizeof (tids));
+
+    /*  Start up the threads. */
+    for (i = 0; i < MAXWORKERS; i++) {
+        rc = pthread_create (&tids[i], NULL, worker, (void *)(intptr_t)fd);
+        if (rc < 0) {
+            fprintf (stderr, "pthread_create: %s\n", strerror (rc));
+            nn_close (fd);
+            break;
+        }
+    }
+
+    /*  Now wait on them to finish. */
+    for (i = 0; i < MAXWORKERS; i++) {
+        if (tids[i] != NULL) {
+            pthread_join (tids[i], NULL);
+        }
+    }
+    return (-1);
+}
+
+/*  The client runs just once, and then returns. */
+int client (const char *url, const char *msecstr)
+{
+    int fd;
+    int rc;
+    char *greeting;
+    uint8_t msg[sizeof (uint32_t)];
+    uint64_t start;
+    uint64_t end;
+    unsigned msec;
+
+    msec = atoi(msecstr);
+
+    fd = nn_socket (AF_SP, NN_REQ);
+    if (fd < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        return (-1);
+    }
+
+    if (nn_connect (fd, url) < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);        
+    }
+
+    msec = htonl(msec);
+    memcpy (msg, &msec, sizeof (msec));
+
+    start = milliseconds ();
+
+    if (nn_send (fd, msg, sizeof (msg), 0) < 0) {
+        fprintf (stderr, "nn_send: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);
+    }
+
+    rc = nn_recv (fd, &msg, sizeof (msg), 0);
+    if (rc < 0) {
+        fprintf (stderr, "nn_recv: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);
+    }
+
+    nn_close (fd);
+
+    end = milliseconds ();
+
+    printf ("Request took %u milliseconds.\n", (uint32_t)(end - start));
+    return (0);
+}
+
+int main (int argc, char **argv)
+{
+    int rc;
+    if (argc < 3) {
+        fprintf (stderr, "Usage: %s <url> [-s|name]\n", argv[0]);
+        exit (EXIT_FAILURE);
+    }
+    if (strcmp (argv[2], "-s") == 0) {
+        rc = server (argv[1]);
+    } else {
+        rc = client (argv[1], argv[2]);
+    }
+    exit (rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+}
diff --git a/demo/pubsub_demo.c b/demo/pubsub_demo.c
new file mode 100644
index 0000000..f9a8fc7
--- /dev/null
+++ b/demo/pubsub_demo.c
@@ -0,0 +1,178 @@
+/*
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom
+    the Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+    IN THE SOFTWARE.
+
+    "nanomsg" is a trademark of Martin Sustrik
+*/
+
+/*  This program serves as an example for how to write a simple PUB SUB
+    service, The server is just a single threaded for loop which broadcasts
+    messages to clients, every so often.  The message is a binary format
+    message, containing two 32-bit unsigned integers.  The first is UNIX time,
+    and the second is the number of directly connected subscribers.
+
+    The clients stay connected and print a message with this information
+    along with their process ID to standard output.
+
+    To run this program, start the server as pubsub_demo <url> -s
+    Then connect to it with the client as pubsub_demo <url>
+    For example:
+
+    % ./pubsub_demo tcp://127.0.0.1:5555 -s &
+    % ./pubsub_demo tcp://127.0.0.1:5555 &
+    % ./pubsub_demo tcp://127.0.0.1:5555 &
+    11:23:54 <pid 1254> There are 2 clients connected.
+    11:24:04 <pid 1255> There are 2 clients connected.
+    ..
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <netinet/in.h>  /* For htonl and ntohl */
+#include <unistd.h>
+
+#include <nanomsg/nn.h>
+#include <nanomsg/pubsub.h>
+
+/*  The server runs forever. */
+int server(const char *url)
+{
+    int fd; 
+
+    /*  Create the socket. */
+    fd = nn_socket (AF_SP, NN_PUB);
+    if (fd < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        return (-1);
+    }
+
+    /*  Bind to the URL.  This will bind to the address and listen
+        synchronously; new clients will be accepted asynchronously
+        without further action from the calling program. */
+
+    if (nn_bind (fd, url) < 0) {
+        fprintf (stderr, "nn_bind: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);
+    }
+
+    /*  Now we can just publish results.  Note that there is no explicit
+        accept required.  We just start writing the information. */
+
+    for (;;) {
+        uint8_t msg[2 * sizeof (uint32_t)];
+        uint32_t secs, subs;
+        int rc;
+
+        secs = (uint32_t) time (NULL);
+        subs = (uint32_t) nn_get_statistic (fd, NN_STAT_CURRENT_CONNECTIONS);
+
+        secs = htonl (secs);
+        subs = htonl (subs);
+
+        memcpy (msg, &secs, sizeof (secs));
+        memcpy (msg + sizeof (secs), &subs, sizeof (subs));
+
+        rc = nn_send (fd, msg, sizeof (msg), 0);
+        if (rc < 0) {
+            /*  There are several legitimate reasons this can fail.
+                We note them for debugging purposes, but then ignore
+                otherwise. */
+            fprintf (stderr, "nn_send: %s (ignoring)\n",
+                nn_strerror (nn_errno ()));
+        }
+        sleep(10);
+    }
+
+    /* NOTREACHED */
+    nn_close (fd);
+    return (-1);
+}
+
+/*  The client runs in a loop, displaying the content. */
+int client (const char *url)
+{
+    int fd;
+    int rc;
+
+    fd = nn_socket (AF_SP, NN_SUB);
+    if (fd < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        return (-1);
+    }
+
+    if (nn_connect (fd, url) < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);        
+    }
+
+    /*  We want all messages, so just subscribe to the empty value. */
+    if (nn_setsockopt (fd, NN_SUB, NN_SUB_SUBSCRIBE, "", 0) < 0) {
+        fprintf (stderr, "nn_setsockopt: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);        
+    }
+
+    for (;;) {
+        uint8_t msg[2 * sizeof (uint32_t)];
+        char hhmmss[9];  /* HH:MM:SS\0 */
+        uint32_t subs, secs;
+        time_t t;
+
+        rc = nn_recv (fd, msg, sizeof (msg), 0);
+        if (rc < 0) {
+            fprintf (stderr, "nn_recv: %s\n", nn_strerror (nn_errno ()));
+            break;
+        }
+        if (rc != sizeof (msg)) {
+            fprintf (stderr, "nn_recv: got %d bytes, wanted %d\n",
+                rc, (int)sizeof (msg));
+             break;
+        }
+        memcpy (&secs, msg, sizeof (secs));
+        memcpy (&subs, msg + sizeof (secs), sizeof (subs));
+
+        t = (time_t) ntohl(secs);
+        strftime (hhmmss, sizeof (hhmmss), "%T", localtime (&t));
+
+        printf ("%s <pid %u> There are %u clients connected.\n", hhmmss,
+            (unsigned) getpid(), (unsigned) ntohl(subs));
+    }
+
+    nn_close (fd);
+    return (-1);
+}
+
+int main (int argc, char **argv)
+{
+    int rc;
+    if ((argc == 3) && (strcmp (argv[2], "-s") == 0)) {
+        rc = server (argv[1]);
+    } else if (argc == 2) {
+        rc = client (argv[1]);
+    } else {
+        fprintf (stderr, "Usage: %s <url> [-s]\n", argv[0]);
+        exit (EXIT_FAILURE);
+    }
+    exit (rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+}
diff --git a/demo/rpc_demo.c b/demo/rpc_demo.c
new file mode 100644
index 0000000..c8d87d6
--- /dev/null
+++ b/demo/rpc_demo.c
@@ -0,0 +1,207 @@
+/*
+    Copyright 2016 Garrett D'Amore <garrett@damore.org>
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom
+    the Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+    IN THE SOFTWARE.
+
+    "nanomsg" is a trademark of Martin Sustrik
+*/
+
+/*  This program serves as an example for how to write a simple RPC service,
+    using the request/reply pattern.  The server is just a single threaded
+    for loop, which processes each request.  The requests run quickly enough
+    that there is no need for parallelism.
+
+    Our demonstration application layer protocol is simple.  The client sends
+    a name, and the server replies with a greeting based on the time of day.
+    The messages are sent in ASCII, and are not zero terminated.
+
+    To run this program, start the server as rpc_demo <url> -s
+    Then connect to it with the client as rpc_client <url> <name>.
+    The client will print a timezone appropriate greeting, based on
+    the time at the server.  For example:
+
+    % ./rpc_demo tcp://127.0.0.1:5555 -s &
+    % ./rpc_demo tcp://127.0.0.1:5555 Garrett
+    Good morning, Garrett.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <nanomsg/nn.h>
+#include <nanomsg/reqrep.h>
+
+/*  The server runs forever. */
+int server(const char *url)
+{
+    int fd; 
+
+    /*  Create the socket. */
+    fd = nn_socket (AF_SP, NN_REP);
+    if (fd < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        return (-1);
+    }
+
+    /*  Bind to the URL.  This will bind to the address and listen
+        synchronously; new clients will be accepted asynchronously
+        without further action from the calling program. */
+
+    if (nn_bind (fd, url) < 0) {
+        fprintf (stderr, "nn_bind: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);
+    }
+
+    /*  Now we can just process results.  Note that there is no explicit
+        accept required.  We just receive a request, and reply to it.
+        Its important to note that we must not issue two receives in a
+        row without replying first, or the following receive(s) will
+        cancel any unreplied requests. */
+
+    for (;;) {
+        char username[128];
+        char greeting[128];
+        time_t secs;
+        struct tm *now;
+        char *daytime;
+        int rc;
+        char *fmt;
+
+        rc = nn_recv (fd, username, sizeof (username), 0);
+        if (rc < 0) {
+            /*  Any error here is unexpected. */
+            fprintf (stderr, "nn_recv: %s\n", nn_strerror (nn_errno ()));
+            break;
+        }
+
+        secs = time (NULL);
+        now = localtime (&secs);
+        if (now->tm_hour < 12) {
+            daytime = "morning";
+
+        } else if (now->tm_hour < 17) {
+            daytime = "afternoon";
+
+        } else if (now->tm_hour < 20) {
+            daytime = "evening";
+
+        } else {
+            daytime = "night";
+        }
+
+        /*  Ensure ASCIIZ terminated string. */
+        if (rc < sizeof (username)) {
+            username[rc] = '\0';
+        } else {
+            username[sizeof (username) - 1] = '\0';
+        }
+
+        fmt = "Good %s, %s.";
+
+        /*  Technically this might be overly pessimistic about size. */
+        if ((strlen (username) + strlen (daytime) + strlen (fmt)) >=
+            sizeof (greeting)) {
+
+            fmt = "I'm sorry, your name is too long.  But good %s anyway.";
+        }
+
+        /*  snprintf would be safer, but the above check protects us. */
+        sprintf (greeting, fmt, daytime, username);
+
+        rc = nn_send (fd, greeting, strlen (greeting), 0);
+        if (rc < 0) {
+            /*  There are several legitimate reasons this can fail.
+                We note them for debugging purposes, but then ignore
+                otherwise.  If the socket is closed or failing, we will
+                notice in recv above, and exit then. */
+            fprintf (stderr, "nn_send: %s (ignoring)\n",
+                nn_strerror (nn_errno ()));
+        }
+    }
+
+    nn_close (fd);
+    return (-1);
+}
+
+/*  The client runs just once, and then returns. */
+int client (const char *url, const char *username)
+{
+    int fd;
+    int rc;
+    char *greeting;
+    char *msg;
+
+    fd = nn_socket (AF_SP, NN_REQ);
+    if (fd < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        return (-1);
+    }
+
+    if (nn_connect (fd, url) < 0) {
+        fprintf (stderr, "nn_socket: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);        
+    }
+
+    if (nn_send (fd, username, strlen (username), 0) < 0) {
+        fprintf (stderr, "nn_send: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);
+    }
+
+    /*  Here we ask the library to allocate response buffer for us (NN_MSG). */
+    rc = nn_recv (fd, &msg, NN_MSG, 0);
+    if (rc < 0) {
+        fprintf (stderr, "nn_recv: %s\n", nn_strerror (nn_errno ()));
+        nn_close (fd);
+        return (-1);
+    }
+
+    nn_close (fd);
+
+    /*  Response is not ASCIIZ terminated. */
+    greeting = malloc (rc + 1);
+    if (greeting == NULL) {
+        fprintf (stderr, "malloc: %s\n", strerror (errno));
+        return (-1);
+    }
+    memcpy(greeting, msg, rc);
+
+    nn_freemsg (msg);
+    printf ("%s\n", greeting); 
+    return (0);
+}
+
+int main (int argc, char **argv)
+{
+    int rc;
+    if (argc < 3) {
+        fprintf (stderr, "Usage: %s <url> [-s|name]\n", argv[0]);
+        exit (EXIT_FAILURE);
+    }
+    if (strcmp (argv[2], "-s") == 0) {
+        rc = server (argv[1]);
+    } else {
+        rc = client (argv[1], argv[2]);
+    }
+    exit (rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+}
diff --git a/tests/README b/tests/README
index 04c2198..e7088b1 100644
--- a/tests/README
+++ b/tests/README
@@ -1,5 +1,9 @@
 This directory contains automatic tests for nanomsg library. To run the tests
-do "make test" in the build directory.
+do "make test" in the build directory, or alternatively run ctest.
 
-The WebSocket stress test depends upon a separate installation of Autobahn
-Testsuite, available at: http://autobahn.ws/testsuite/installation.html
+Note that the code here is probably ill-suited for demonstration purposes, as
+it is primarily oriented towards testing the library, rather than serving as
+any sort of example.
+
+Instead, we recommend looking in ../demo for some example programs that
+demonstrate the API as we feel it is meant to be used.