diff --git a/src/win/async.c b/src/win/async.c
index 87f55296..99e0fa56 100644
--- a/src/win/async.c
+++ b/src/win/async.c
@@ -23,6 +23,7 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "req-inl.h"
 
 
 /* Atomic set operation on char */
diff --git a/src/win/core.c b/src/win/core.c
index 57ef1c14..3405c98d 100644
--- a/src/win/core.c
+++ b/src/win/core.c
@@ -28,6 +28,7 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "req-inl.h"
 
 
 /* The only event loop we support right now */
diff --git a/src/win/fs-event.c b/src/win/fs-event.c
index 30a571a7..71b37c61 100644
--- a/src/win/fs-event.c
+++ b/src/win/fs-event.c
@@ -19,15 +19,16 @@
  * IN THE SOFTWARE.
  */
 
-#include "uv.h"
-#include "internal.h"
-
 #include <assert.h>
 #include <malloc.h>
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
 
+#include "uv.h"
+#include "internal.h"
+#include "req-inl.h"
+
 
 const unsigned int uv_directory_watcher_buffer_size = 4096;
 
diff --git a/src/win/fs.c b/src/win/fs.c
index 5df4829d..b6b97393 100644
--- a/src/win/fs.c
+++ b/src/win/fs.c
@@ -32,6 +32,8 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "req-inl.h"
+
 
 #define UV_FS_ASYNC_QUEUED       0x0001
 #define UV_FS_FREE_PATH          0x0002
diff --git a/src/win/getaddrinfo.c b/src/win/getaddrinfo.c
index bdfe1bb9..41e7a4aa 100644
--- a/src/win/getaddrinfo.c
+++ b/src/win/getaddrinfo.c
@@ -24,6 +24,7 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "req-inl.h"
 
 
 /*
diff --git a/src/win/internal.h b/src/win/internal.h
index 0dff80cd..12e73f32 100644
--- a/src/win/internal.h
+++ b/src/win/internal.h
@@ -146,15 +146,8 @@ void uv_handle_init(uv_loop_t* loop, uv_handle_t* handle);
 
 
 /*
- * Requests
+ * Requests (also see req-inl.h)
  */
-void uv_req_init(uv_loop_t* loop, uv_req_t* req);
-
-uv_req_t* uv_overlapped_to_req(OVERLAPPED* overlapped);
-
-void uv_insert_pending_req(uv_loop_t* loop, uv_req_t* req);
-void uv_process_reqs(uv_loop_t* loop);
-
 #define POST_COMPLETION_FOR_REQ(loop, req)                              \
   if (!PostQueuedCompletionStatus((loop)->iocp,                         \
                                   0,                                    \
diff --git a/src/win/pipe.c b/src/win/pipe.c
index 8a64f71b..bb21eaeb 100644
--- a/src/win/pipe.c
+++ b/src/win/pipe.c
@@ -26,6 +26,7 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "req-inl.h"
 
 
 /* A zero-size buffer for use by uv_pipe_read */
diff --git a/src/win/poll.c b/src/win/poll.c
index 55776f7a..5a2d5e95 100644
--- a/src/win/poll.c
+++ b/src/win/poll.c
@@ -19,12 +19,12 @@
  * IN THE SOFTWARE.
  */
 
+#include <assert.h>
+#include <io.h>
 
 #include "uv.h"
 #include "internal.h"
-
-#include <assert.h>
-#include <io.h>
+#include "req-inl.h"
 
 
 static const GUID uv_msafd_provider_ids[UV_MSAFD_PROVIDER_COUNT] = {
diff --git a/src/win/process.c b/src/win/process.c
index c6ca922e..0acff3ee 100644
--- a/src/win/process.c
+++ b/src/win/process.c
@@ -19,15 +19,15 @@
  * IN THE SOFTWARE.
  */
 
-#include "uv.h"
-#include "internal.h"
-
 #include <assert.h>
 #include <io.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <signal.h>
-#include <windows.h>
+
+#include "uv.h"
+#include "internal.h"
+#include "req-inl.h"
 
 
 #define SIGKILL         9
diff --git a/src/win/req-inl.h b/src/win/req-inl.h
new file mode 100644
index 00000000..dbead2df
--- /dev/null
+++ b/src/win/req-inl.h
@@ -0,0 +1,169 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * 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.
+ */
+
+#include <assert.h>
+
+#include "uv.h"
+#include "internal.h"
+
+
+INLINE static void uv_req_init(uv_loop_t* loop, uv_req_t* req) {
+  loop->counters.req_init++;
+  req->type = UV_UNKNOWN_REQ;
+  SET_REQ_SUCCESS(req);
+}
+
+
+INLINE static uv_req_t* uv_overlapped_to_req(OVERLAPPED* overlapped) {
+  return CONTAINING_RECORD(overlapped, uv_req_t, overlapped);
+}
+
+
+INLINE static void uv_insert_pending_req(uv_loop_t* loop, uv_req_t* req) {
+  req->next_req = NULL;
+  if (loop->pending_reqs_tail) {
+    req->next_req = loop->pending_reqs_tail->next_req;
+    loop->pending_reqs_tail->next_req = req;
+    loop->pending_reqs_tail = req;
+  } else {
+    req->next_req = req;
+    loop->pending_reqs_tail = req;
+  }
+}
+
+
+#define DELEGATE_STREAM_REQ(loop, req, method, handle_at)                     \
+  do {                                                                        \
+    switch (((uv_handle_t*) (req)->handle_at)->type) {                        \
+      case UV_TCP:                                                            \
+        uv_process_tcp_##method##_req(loop,                                   \
+                                      (uv_tcp_t*) ((req)->handle_at),         \
+                                      req);                                   \
+        break;                                                                \
+                                                                              \
+      case UV_NAMED_PIPE:                                                     \
+        uv_process_pipe_##method##_req(loop,                                  \
+                                       (uv_pipe_t*) ((req)->handle_at),       \
+                                       req);                                  \
+        break;                                                                \
+                                                                              \
+      case UV_TTY:                                                            \
+        uv_process_tty_##method##_req(loop,                                   \
+                                      (uv_tty_t*) ((req)->handle_at),         \
+                                      req);                                   \
+        break;                                                                \
+                                                                              \
+      default:                                                                \
+        assert(0);                                                            \
+    }                                                                         \
+  } while (0)
+
+
+INLINE static void uv_process_reqs(uv_loop_t* loop) {
+  uv_req_t* req;
+  uv_req_t* first;
+  uv_req_t* next;
+
+  if (loop->pending_reqs_tail == NULL) {
+    return;
+  }
+
+  first = loop->pending_reqs_tail->next_req;
+  next = first;
+  loop->pending_reqs_tail = NULL;
+
+  while (next != NULL) {
+    req = next;
+    next = req->next_req != first ? req->next_req : NULL;
+
+    switch (req->type) {
+      case UV_READ:
+        DELEGATE_STREAM_REQ(loop, req, read, data);
+        break;
+
+      case UV_WRITE:
+        DELEGATE_STREAM_REQ(loop, (uv_write_t*) req, write, handle);
+        break;
+
+      case UV_ACCEPT:
+        DELEGATE_STREAM_REQ(loop, req, accept, data);
+        break;
+
+      case UV_CONNECT:
+        DELEGATE_STREAM_REQ(loop, (uv_connect_t*) req, connect, handle);
+        break;
+
+      case UV_SHUTDOWN:
+        /* Tcp shutdown requests don't come here. */
+        assert(((uv_shutdown_t*) req)->handle->type == UV_NAMED_PIPE);
+        uv_process_pipe_shutdown_req(
+            loop,
+            (uv_pipe_t*) ((uv_shutdown_t*) req)->handle,
+            (uv_shutdown_t*) req);
+        break;
+
+      case UV_UDP_RECV:
+        uv_process_udp_recv_req(loop, (uv_udp_t*) req->data, req);
+        break;
+
+      case UV_UDP_SEND:
+        uv_process_udp_send_req(loop,
+                                ((uv_udp_send_t*) req)->handle,
+                                (uv_udp_send_t*) req);
+        break;
+
+      case UV_WAKEUP:
+        uv_process_async_wakeup_req(loop, (uv_async_t*) req->data, req);
+        break;
+
+      case UV_POLL_REQ:
+        uv_process_poll_req(loop, (uv_poll_t*) req->data, req);
+        break;
+
+      case UV_GETADDRINFO:
+        uv_process_getaddrinfo_req(loop, (uv_getaddrinfo_t*) req);
+        break;
+
+      case UV_PROCESS_EXIT:
+        uv_process_proc_exit(loop, (uv_process_t*) req->data);
+        break;
+
+      case UV_PROCESS_CLOSE:
+        uv_process_proc_close(loop, (uv_process_t*) req->data);
+        break;
+
+      case UV_FS:
+        uv_process_fs_req(loop, (uv_fs_t*) req);
+        break;
+
+      case UV_WORK:
+        uv_process_work_req(loop, (uv_work_t*) req);
+        break;
+
+      case UV_FS_EVENT_REQ:
+        uv_process_fs_event_req(loop, req, (uv_fs_event_t*) req->data);
+        break;
+
+      default:
+        assert(0);
+    }
+  }
+}
diff --git a/src/win/req.c b/src/win/req.c
index ada4eb1b..111cc5e2 100644
--- a/src/win/req.c
+++ b/src/win/req.c
@@ -23,147 +23,3 @@
 
 #include "uv.h"
 #include "internal.h"
-
-
-void uv_req_init(uv_loop_t* loop, uv_req_t* req) {
-  loop->counters.req_init++;
-  req->type = UV_UNKNOWN_REQ;
-  SET_REQ_SUCCESS(req);
-}
-
-
-uv_req_t* uv_overlapped_to_req(OVERLAPPED* overlapped) {
-  return CONTAINING_RECORD(overlapped, uv_req_t, overlapped);
-}
-
-
-void uv_insert_pending_req(uv_loop_t* loop, uv_req_t* req) {
-  req->next_req = NULL;
-  if (loop->pending_reqs_tail) {
-    req->next_req = loop->pending_reqs_tail->next_req;
-    loop->pending_reqs_tail->next_req = req;
-    loop->pending_reqs_tail = req;
-  } else {
-    req->next_req = req;
-    loop->pending_reqs_tail = req;
-  }
-}
-
-
-#define DELEGATE_STREAM_REQ(loop, req, method, handle_at)                     \
-  do {                                                                        \
-    switch (((uv_handle_t*) (req)->handle_at)->type) {                        \
-      case UV_TCP:                                                            \
-        uv_process_tcp_##method##_req(loop,                                   \
-                                      (uv_tcp_t*) ((req)->handle_at),         \
-                                      req);                                   \
-        break;                                                                \
-                                                                              \
-      case UV_NAMED_PIPE:                                                     \
-        uv_process_pipe_##method##_req(loop,                                  \
-                                       (uv_pipe_t*) ((req)->handle_at),       \
-                                       req);                                  \
-        break;                                                                \
-                                                                              \
-      case UV_TTY:                                                            \
-        uv_process_tty_##method##_req(loop,                                   \
-                                      (uv_tty_t*) ((req)->handle_at),         \
-                                      req);                                   \
-        break;                                                                \
-                                                                              \
-      default:                                                                \
-        assert(0);                                                            \
-    }                                                                         \
-  } while (0)
-
-
-void uv_process_reqs(uv_loop_t* loop) {
-  uv_req_t* req;
-  uv_req_t* first;
-  uv_req_t* next;
-
-  if (loop->pending_reqs_tail == NULL) {
-    return;
-  }
-
-  first = loop->pending_reqs_tail->next_req;
-  next = first;
-  loop->pending_reqs_tail = NULL;
-
-  while (next != NULL) {
-    req = next;
-    next = req->next_req != first ? req->next_req : NULL;
-
-    switch (req->type) {
-      case UV_READ:
-        DELEGATE_STREAM_REQ(loop, req, read, data);
-        break;
-
-      case UV_WRITE:
-        DELEGATE_STREAM_REQ(loop, (uv_write_t*) req, write, handle);
-        break;
-
-      case UV_ACCEPT:
-        DELEGATE_STREAM_REQ(loop, req, accept, data);
-        break;
-
-      case UV_CONNECT:
-        DELEGATE_STREAM_REQ(loop, (uv_connect_t*) req, connect, handle);
-        break;
-
-      case UV_SHUTDOWN:
-        /* Tcp shutdown requests don't come here. */
-        assert(((uv_shutdown_t*) req)->handle->type == UV_NAMED_PIPE);
-        uv_process_pipe_shutdown_req(
-            loop,
-            (uv_pipe_t*) ((uv_shutdown_t*) req)->handle,
-            (uv_shutdown_t*) req);
-        break;
-
-      case UV_UDP_RECV:
-        uv_process_udp_recv_req(loop, (uv_udp_t*) req->data, req);
-        break;
-
-      case UV_UDP_SEND:
-        uv_process_udp_send_req(loop,
-                                ((uv_udp_send_t*) req)->handle,
-                                (uv_udp_send_t*) req);
-        break;
-
-      case UV_WAKEUP:
-        uv_process_async_wakeup_req(loop, (uv_async_t*) req->data, req);
-        break;
-
-      case UV_POLL_REQ:
-        uv_process_poll_req(loop, (uv_poll_t*) req->data, req);
-        break;
-
-      case UV_GETADDRINFO:
-        uv_process_getaddrinfo_req(loop, (uv_getaddrinfo_t*) req);
-        break;
-
-      case UV_PROCESS_EXIT:
-        uv_process_proc_exit(loop, (uv_process_t*) req->data);
-        break;
-
-      case UV_PROCESS_CLOSE:
-        uv_process_proc_close(loop, (uv_process_t*) req->data);
-        break;
-
-      case UV_FS:
-        uv_process_fs_req(loop, (uv_fs_t*) req);
-        break;
-
-      case UV_WORK:
-        uv_process_work_req(loop, (uv_work_t*) req);
-        break;
-
-      case UV_FS_EVENT_REQ:
-        uv_process_fs_event_req(loop, req, (uv_fs_event_t*) req->data);
-        break;
-
-      default:
-        assert(0);
-    }
-  }
-}
diff --git a/src/win/stream.c b/src/win/stream.c
index dad8669b..94551a43 100644
--- a/src/win/stream.c
+++ b/src/win/stream.c
@@ -23,6 +23,7 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "req-inl.h"
 
 
 void uv_stream_init(uv_loop_t* loop, uv_stream_t* handle) {
diff --git a/src/win/tcp.c b/src/win/tcp.c
index c049d64d..937eae11 100644
--- a/src/win/tcp.c
+++ b/src/win/tcp.c
@@ -23,6 +23,8 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "req-inl.h"
+
 
 
 /*
diff --git a/src/win/threadpool.c b/src/win/threadpool.c
index e066810d..48e00b87 100644
--- a/src/win/threadpool.c
+++ b/src/win/threadpool.c
@@ -23,6 +23,7 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "req-inl.h"
 
 
 static void uv_work_req_init(uv_loop_t* loop, uv_work_t* req,
diff --git a/src/win/tty.c b/src/win/tty.c
index c662e093..aaa29b6e 100644
--- a/src/win/tty.c
+++ b/src/win/tty.c
@@ -26,6 +26,7 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "req-inl.h"
 
 
 #define UNICODE_REPLACEMENT_CHARACTER (0xfffd)
diff --git a/src/win/udp.c b/src/win/udp.c
index 3ea23f9d..4ff71c45 100644
--- a/src/win/udp.c
+++ b/src/win/udp.c
@@ -23,6 +23,7 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "req-inl.h"
 
 
 /*
diff --git a/uv.gyp b/uv.gyp
index 0a9e39dd..ec674073 100644
--- a/uv.gyp
+++ b/uv.gyp
@@ -149,6 +149,7 @@
             'src/win/poll.c',
             'src/win/process.c',
             'src/win/req.c',
+            'src/win/req-inl.h',
             'src/win/stream.c',
             'src/win/tcp.c',
             'src/win/tty.c',