diff --git a/alloc.c b/alloc.c
index 0902286..734ea71 100644
--- a/alloc.c
+++ b/alloc.c
@@ -27,6 +27,9 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
+  
+/* turn of windows warnings for _strcmp etc. */
+#define _CRT_NONSTDC_NO_DEPRECATE
 
 #include "fmacros.h"
 #include "alloc.h"
diff --git a/async.c b/async.c
index 1f70dc9..67322cc 100644
--- a/async.c
+++ b/async.c
@@ -29,6 +29,9 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+/* turn of windows warnings for _strcmp etc. */
+#define _CRT_NONSTDC_NO_DEPRECATE
+
 #include "fmacros.h"
 #include "alloc.h"
 #include <stdlib.h>
@@ -75,7 +78,7 @@ static void *callbackValDup(void *privdata, const void *src) {
 }
 
 static int callbackKeyCompare(void *privdata, const void *key1, const void *key2) {
-    int l1, l2;
+    size_t l1, l2;
     ((void) privdata);
 
     l1 = sdslen((const sds)key1);
diff --git a/dict.c b/dict.c
index ad57181..9d3d8dd 100644
--- a/dict.c
+++ b/dict.c
@@ -51,7 +51,7 @@ static int _dictInit(dict *ht, dictType *type, void *privDataPtr);
 
 /* Generic hash function (a popular one from Bernstein).
  * I tested a few and this was the best. */
-static unsigned int dictGenHashFunction(const unsigned char *buf, int len) {
+static unsigned int dictGenHashFunction(const unsigned char *buf, size_t len) {
     unsigned int hash = 5381;
 
     while (len--)
diff --git a/dict.h b/dict.h
index 6ad0acd..cef43e7 100644
--- a/dict.h
+++ b/dict.h
@@ -111,7 +111,7 @@ typedef struct dictIterator {
 #define dictSize(ht) ((ht)->used)
 
 /* API */
-static unsigned int dictGenHashFunction(const unsigned char *buf, int len);
+static unsigned int dictGenHashFunction(const unsigned char *buf, size_t len);
 static dict *dictCreate(dictType *type, void *privDataPtr);
 static int dictExpand(dict *ht, unsigned long size);
 static int dictAdd(dict *ht, void *key, void *val);
diff --git a/hiredis.c b/hiredis.c
index 739ce2a..1b378a2 100644
--- a/hiredis.c
+++ b/hiredis.c
@@ -323,12 +323,12 @@ static size_t bulklen(size_t len) {
 int redisvFormatCommand(char **target, const char *format, va_list ap) {
     const char *c = format;
     char *cmd = NULL; /* final command */
-    int pos; /* position in final command */
+    size_t pos; /* position in final command */
     sds curarg, newarg; /* current argument */
     int touched = 0; /* was the current argument touched? */
     char **curargv = NULL, **newargv = NULL;
     int argc = 0;
-    int totlen = 0;
+    size_t totlen = 0;
     int error_type = 0; /* 0 = no error; -1 = memory error; -2 = format error */
     int j;
 
@@ -534,7 +534,7 @@ int redisvFormatCommand(char **target, const char *format, va_list ap) {
 
     hi_free(curargv);
     *target = cmd;
-    return totlen;
+    return (int)totlen;
 
 format_err:
     error_type = -2;
@@ -594,7 +594,7 @@ long long redisFormatSdsCommandArgv(sds *target, int argc, const char **argv,
                                     const size_t *argvlen)
 {
     sds cmd, aux;
-    unsigned long long totlen, len;
+    size_t totlen, len;
     int j;
 
     /* Abort on a NULL target */
@@ -626,7 +626,7 @@ long long redisFormatSdsCommandArgv(sds *target, int argc, const char **argv,
     cmd = sdscatfmt(cmd, "*%i\r\n", argc);
     for (j=0; j < argc; j++) {
         len = argvlen ? argvlen[j] : strlen(argv[j]);
-        cmd = sdscatfmt(cmd, "$%U\r\n", len);
+        cmd = sdscatfmt(cmd, "$%U\r\n", (unsigned long long)len);
         cmd = sdscatlen(cmd, argv[j], len);
         cmd = sdscatlen(cmd, "\r\n", sizeof("\r\n")-1);
     }
@@ -634,7 +634,7 @@ long long redisFormatSdsCommandArgv(sds *target, int argc, const char **argv,
     assert(sdslen(cmd)==totlen);
 
     *target = cmd;
-    return totlen;
+    return (long long) totlen; /* api doesn't use ssize_t */
 }
 
 void redisFreeSdsCommand(sds cmd) {
@@ -681,7 +681,7 @@ long long redisFormatCommandArgv(char **target, int argc, const char **argv, con
     cmd[pos] = '\0';
 
     *target = cmd;
-    return totlen;
+    return (long long) totlen;  /* api doesn't use ssize_t */
 }
 
 void redisFreeCommand(char *cmd) {
@@ -979,7 +979,7 @@ redisPushFn *redisSetPushCallback(redisContext *c, redisPushFn *fn) {
  * see if there is a reply available. */
 int redisBufferRead(redisContext *c) {
     char buf[1024*16];
-    int nread;
+    ssize_t nread;
 
     /* Return early when the context has seen an error. */
     if (c->err)
diff --git a/net.c b/net.c
index b514bab..04319ca 100644
--- a/net.c
+++ b/net.c
@@ -327,7 +327,7 @@ static int redisContextWaitReady(redisContext *c, long msec) {
 }
 
 int redisCheckConnectDone(redisContext *c, int *completed) {
-    int rc = connect(c->fd, (const struct sockaddr *)c->saddr, c->addrlen);
+    int rc = connect(c->fd, (const struct sockaddr *)c->saddr, (socklen_t)c->addrlen);
     if (rc == 0) {
         *completed = 1;
         return REDIS_OK;
@@ -386,7 +386,7 @@ int redisCheckSocketError(redisContext *c) {
 
 int redisContextSetTimeout(redisContext *c, const struct timeval tv) {
     const void *to_ptr = &tv;
-    size_t to_sz = sizeof(tv);
+    socklen_t to_sz = sizeof(tv);
 
     if (redisContextUpdateCommandTimeout(c, &tv) != REDIS_OK) {
         __redisSetError(c, REDIS_ERR_OOM, "Out of memory");
@@ -539,7 +539,7 @@ addrretry:
             }
 
             for (b = bservinfo; b != NULL; b = b->ai_next) {
-                if (bind(s,b->ai_addr,b->ai_addrlen) != -1) {
+                if (bind(s,b->ai_addr,(socklen_t)b->ai_addrlen) != -1) {
                     bound = 1;
                     break;
                 }
@@ -562,7 +562,7 @@ addrretry:
         memcpy(c->saddr, p->ai_addr, p->ai_addrlen);
         c->addrlen = p->ai_addrlen;
 
-        if (connect(s,p->ai_addr,p->ai_addrlen) == -1) {
+        if (connect(s,p->ai_addr,(socklen_t)p->ai_addrlen) == -1) {
             if (errno == EHOSTUNREACH) {
                 redisNetClose(c);
                 continue;
@@ -682,13 +682,13 @@ int redisContextConnectUnix(redisContext *c, const char *path, const struct time
 
     c->flags |= REDIS_CONNECTED;
     return REDIS_OK;
+oom:
+    __redisSetError(c, REDIS_ERR_OOM, "Out of memory");
+    return REDIS_ERR;
 #else
     /* We currently do not support Unix sockets for Windows. */
     /* TODO(m): https://devblogs.microsoft.com/commandline/af_unix-comes-to-windows/ */
     errno = EPROTONOSUPPORT;
     return REDIS_ERR;
 #endif /* _WIN32 */
-oom:
-    __redisSetError(c, REDIS_ERR_OOM, "Out of memory");
-    return REDIS_ERR;
 }
diff --git a/read.c b/read.c
index ebbe02c..5aeda7a 100644
--- a/read.c
+++ b/read.c
@@ -29,6 +29,9 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+/* turn of windows warnings for _strcmp etc. */
+#define _CRT_NONSTDC_NO_DEPRECATE
+
 #include "fmacros.h"
 #include <string.h>
 #include <stdlib.h>
@@ -213,7 +216,7 @@ static int string2ll(const char *s, size_t slen, long long *value) {
     if (negative) {
         if (v > ((unsigned long long)(-(LLONG_MIN+1))+1)) /* Overflow. */
             return REDIS_ERR;
-        if (value != NULL) *value = -v;
+        if (value != NULL) *value = -(long long)v;
     } else {
         if (v > LLONG_MAX) /* Overflow. */
             return REDIS_ERR;
@@ -222,9 +225,9 @@ static int string2ll(const char *s, size_t slen, long long *value) {
     return REDIS_OK;
 }
 
-static char *readLine(redisReader *r, int *_len) {
+static char *readLine(redisReader *r, size_t *_len) {
     char *p, *s;
-    int len;
+    size_t len;
 
     p = r->buf+r->pos;
     s = seekNewline(p,(r->len-r->pos));
@@ -270,7 +273,7 @@ static int processLineItem(redisReader *r) {
     redisReadTask *cur = r->task[r->ridx];
     void *obj;
     char *p;
-    int len;
+    size_t len;
 
     if ((p = readLine(r,&len)) != NULL) {
         if (cur->type == REDIS_REPLY_INTEGER) {
@@ -291,7 +294,7 @@ static int processLineItem(redisReader *r) {
             char buf[326], *eptr;
             double d;
 
-            if ((size_t)len >= sizeof(buf)) {
+            if (len >= sizeof(buf)) {
                 __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
                         "Double value is too large");
                 return REDIS_ERR;
@@ -353,7 +356,7 @@ static int processLineItem(redisReader *r) {
         } else if (cur->type == REDIS_REPLY_BIGNUM) {
             /* Ensure all characters are decimal digits (with possible leading
              * minus sign). */
-            for (int i = 0; i < len; i++) {
+            for (size_t i = 0; i < len; i++) {
                 /* XXX Consider: Allow leading '+'? Error on leading '0's? */
                 if (i == 0 && p[0] == '-') continue;
                 if (p[i] < '0' || p[i] > '9') {
@@ -368,7 +371,7 @@ static int processLineItem(redisReader *r) {
                 obj = (void*)REDIS_REPLY_BIGNUM;
         } else {
             /* Type will be error or status. */
-            for (int i = 0; i < len; i++) {
+            for (size_t i = 0; i < len; i++) {
                 if (p[i] == '\r' || p[i] == '\n') {
                     __redisReaderSetError(r,REDIS_ERR_PROTOCOL,
                             "Bad simple string value");
@@ -400,7 +403,7 @@ static int processBulkItem(redisReader *r) {
     void *obj = NULL;
     char *p, *s;
     long long len;
-    unsigned long bytelen;
+    size_t bytelen;
     int success = 0;
 
     p = r->buf+r->pos;
@@ -498,7 +501,8 @@ static int processAggregateItem(redisReader *r) {
     void *obj;
     char *p;
     long long elements;
-    int root = 0, len;
+    int root = 0;
+    size_t len;
 
     if (r->ridx == r->tasks - 1) {
         if (redisReaderGrow(r) == REDIS_ERR)
diff --git a/sds.c b/sds.c
index c0388bd..83ac2de 100644
--- a/sds.c
+++ b/sds.c
@@ -99,27 +99,27 @@ sds sdsnewlen(const void *init, size_t initlen) {
     fp = ((unsigned char*)s)-1;
     switch(type) {
         case SDS_TYPE_5: {
-            *fp = type | (initlen << SDS_TYPE_BITS);
+            *fp = type | ((char)initlen << SDS_TYPE_BITS);
             break;
         }
         case SDS_TYPE_8: {
             SDS_HDR_VAR(8,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
+            sh->len = (uint8_t) initlen;
+            sh->alloc = (uint8_t) initlen;
             *fp = type;
             break;
         }
         case SDS_TYPE_16: {
             SDS_HDR_VAR(16,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
+            sh->len = (uint16_t)initlen;
+            sh->alloc = (uint16_t)initlen;
             *fp = type;
             break;
         }
         case SDS_TYPE_32: {
             SDS_HDR_VAR(32,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
+            sh->len = (uint32_t)initlen;
+            sh->alloc = (uint32_t)initlen;
             *fp = type;
             break;
         }
@@ -431,7 +431,7 @@ sds sdscpy(sds s, const char *t) {
  * The function returns the length of the null-terminated string
  * representation stored at 's'. */
 #define SDS_LLSTR_SIZE 21
-int sdsll2str(char *s, long long value) {
+size_t sdsll2str(char *s, long long value) {
     char *p, aux;
     unsigned long long v;
     size_t l;
@@ -463,7 +463,7 @@ int sdsll2str(char *s, long long value) {
 }
 
 /* Identical sdsll2str(), but for unsigned long long type. */
-int sdsull2str(char *s, unsigned long long v) {
+size_t sdsull2str(char *s, unsigned long long v) {
     char *p, aux;
     size_t l;
 
@@ -497,7 +497,7 @@ int sdsull2str(char *s, unsigned long long v) {
  */
 sds sdsfromlonglong(long long value) {
     char buf[SDS_LLSTR_SIZE];
-    int len = sdsll2str(buf,value);
+    size_t len = sdsll2str(buf,value);
 
     return sdsnewlen(buf,len);
 }
@@ -583,7 +583,7 @@ sds sdscatprintf(sds s, const char *fmt, ...) {
  */
 sds sdscatfmt(sds s, char const *fmt, ...) {
     const char *f = fmt;
-    long i;
+    size_t i;
     va_list ap;
 
     va_start(ap,fmt);
@@ -789,7 +789,7 @@ int sdscmp(const sds s1, const sds s2) {
     l2 = sdslen(s2);
     minlen = (l1 < l2) ? l1 : l2;
     cmp = memcmp(s1,s2,minlen);
-    if (cmp == 0) return l1-l2;
+    if (cmp == 0) return l1 < l2 ? -1 : 1;
     return cmp;
 }
 
diff --git a/test.c b/test.c
index 62dd102..3a3b0d2 100644
--- a/test.c
+++ b/test.c
@@ -1,3 +1,6 @@
+/* turn of windows warnings for _strcmp etc. */
+#define _CRT_NONSTDC_NO_DEPRECATE
+
 #include "fmacros.h"
 #include "sockcompat.h"
 #include <stdio.h>
@@ -190,7 +193,7 @@ static void send_client_tracking(redisContext *c, const char *str) {
     freeReplyObject(reply);
 }
 
-static int disconnect(redisContext *c, int keep_fd) {
+static redisFD disconnect(redisContext *c, int keep_fd) {
     redisReply *reply;
 
     /* Make sure we're on DB 9. */
@@ -203,9 +206,9 @@ static int disconnect(redisContext *c, int keep_fd) {
 
     /* Free the context as well, but keep the fd if requested. */
     if (keep_fd)
-        return redisFreeKeepFd(c);
+        return (int)redisFreeKeepFd(c);
     redisFree(c);
-    return -1;
+    return REDIS_INVALID_FD;
 }
 
 static void do_ssl_handshake(redisContext *c) {
@@ -234,8 +237,8 @@ static redisContext *do_connect(struct config config) {
         /* Create a dummy connection just to get an fd to inherit */
         redisContext *dummy_ctx = redisConnectUnix(config.unix_sock.path);
         if (dummy_ctx) {
-            int fd = disconnect(dummy_ctx, 1);
-            printf("Connecting to inherited fd %d\n", fd);
+            redisFD fd = disconnect(dummy_ctx, 1);
+            printf("Connecting to inherited fd %d\n", (int)fd);
             c = redisConnectFd(fd);
         }
     } else {
@@ -268,7 +271,7 @@ static void do_reconnect(redisContext *c, struct config config) {
 
 static void test_format_commands(void) {
     char *cmd;
-    int len;
+    long long len;
 
     test("Format command without interpolation: ");
     len = redisFormatCommand(&cmd,"SET foo bar");
@@ -891,7 +894,7 @@ static void *hi_calloc_insecure(size_t nmemb, size_t size) {
     (void)nmemb;
     (void)size;
     insecure_calloc_calls++;
-    return (void*)0xdeadc0de;
+    return (void*)(uintptr_t)0xdeadc0de;
 }
 
 static void *hi_realloc_fail(void *ptr, size_t size) {