diff --git a/src/core/ipv6/ethip6.c b/src/core/ipv6/ethip6.c
index eedc1f9..6a19bae 100644
--- a/src/core/ipv6/ethip6.c
+++ b/src/core/ipv6/ethip6.c
@@ -51,6 +51,9 @@
 #include "lwip/inet_chksum.h"
 #include "lwip/netif.h"
 #include "lwip/icmp6.h"
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+#include "lwip/ip6_route_table.h"
+#endif
 
 #include <string.h>
 
@@ -137,6 +140,9 @@ ethip6_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr)
 {
   struct eth_addr dest;
   s8_t i;
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+  ip6_addr_t *gateway = NULL;
+#endif
 
   /* make room for Ethernet header - should not fail */
   if (pbuf_header(q, sizeof(struct eth_hdr)) != 0) {
@@ -162,6 +168,27 @@ ethip6_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr)
 
   /* We have a unicast destination IP address */
   /* TODO anycast? */
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+  /* See if a gateway is present for the destination address in the static route table */
+#ifdef LWIP_HOOK_ETHIP6_GET_GW
+  gateway = LWIP_HOOK_ETHIP6_GET_GW(netif, ip6addr);
+#endif
+  if (gateway != NULL) {
+    i = nd6_search_destination_cache_entry(ip6addr);
+    if (i < 0) {
+      /* Not found. Create a new destination entry. */
+      i = nd6_create_destination_cache_entry();
+      if (i < 0) {
+        /* Could not create a destination cache entry. */
+        return ERR_MEM;
+      }
+    }
+
+    /* Add gateway as next hop into destination cache */
+    destination_cache[i].pmtu = netif->mtu; /* Start with netif mtu, correct through ICMPv6 if necessary */
+    ip6_addr_copy(destination_cache[i].next_hop_addr, *gateway);
+  }
+#endif
   /* Get next hop record. */
   i = nd6_get_next_hop_entry(ip6addr, netif);
   if (i < 0) {
diff --git a/src/core/ipv6/ip6.c b/src/core/ipv6/ip6.c
index f4bc4af..01cf13f 100644
--- a/src/core/ipv6/ip6.c
+++ b/src/core/ipv6/ip6.c
@@ -60,6 +60,10 @@
 #include "lwip/debug.h"
 #include "lwip/stats.h"
 
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+#include "lwip/ip6_route_table.h"
+#endif
+
 #if !LWIP_IPV4
 /** Global data for IPv6 only */
 struct ip_globals ip_data;
diff --git a/src/core/ipv6/ip6_route_table.c b/src/core/ipv6/ip6_route_table.c
new file mode 100644
index 0000000..1097803
--- /dev/null
+++ b/src/core/ipv6/ip6_route_table.c
@@ -0,0 +1,270 @@
+/**
+ * @file
+ *
+ * IPv6 static route table.
+ */
+
+/*
+ * Copyright (c) 2015 Nest Labs, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * Author: Pradip De <pde@nestlabs.com>
+ *
+ *
+ * Please coordinate changes and requests with Pradip De
+ * <pde@nestlabs.com>
+ */
+
+#include "lwip/opt.h"
+
+#if LWIP_IPV6  /* don't build if not configured for use in lwipopts.h */
+
+#include "lwip/def.h"
+#include "lwip/mem.h"
+#include "lwip/netif.h"
+#include "lwip/ip6.h"
+#include "lwip/ip6_route_table.h"
+#include "lwip/ip6_addr.h"
+#include "lwip/nd6.h"
+#include "lwip/debug.h"
+#include "lwip/stats.h"
+
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+
+static struct ip6_route_entry static_route_table[LWIP_IPV6_NUM_ROUTE_ENTRIES];
+
+/**
+ * Compare two IPv6 addresses upto a given prefix length in bytes.
+ *
+ * @param addr1 First IPv6 address.
+ * @param addr2 Second IPv6 address.
+ * @param len_in_bytes prefix length in bytes.
+ * @return +1 if match, else 0.
+ */
+s8_t 
+ip6_addr_cmp_upto_bytenum(ip6_addr_t *addr1, ip6_addr_t *addr2, u8_t len_in_bytes)
+{
+  s8_t result = 1;
+  int i;
+  int four_byte_blocks = len_in_bytes / sizeof(u32_t);
+  int remainder_bytes = len_in_bytes % sizeof(u32_t);
+
+  /* Compare the 4 byte blocks directly */
+  for (i = 0; i < four_byte_blocks; i++) {
+    if (addr1->addr[i] == addr2->addr[i]) {
+      continue;
+    } else {
+      result = 0;
+      break;
+    }
+  }
+
+  /* Compare the remainder bytes from the ith word */
+  if (result) {
+    switch(remainder_bytes) {
+    case 1:
+      if ((htonl(addr1->addr[i]) >> 24 & 0x000000ff) !=
+          (htonl(addr2->addr[i]) >> 24 & 0x000000ff)) {
+        result = 0;
+      }
+      break;
+    case 2:
+      if ((htonl(addr1->addr[i]) >> 16 & 0x0000ffff) !=
+          (htonl(addr2->addr[i]) >> 16 & 0x0000ffff)) {
+        result = 0;
+      }
+      break;
+    case 3:
+      if ((htonl(addr1->addr[i]) >> 8 & 0x00ffffff) !=
+          (htonl(addr2->addr[i]) >> 8 & 0x00ffffff)) {
+        result = 0;
+      }
+      break;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Add the ip6 prefix route and target netif into the static route table while
+ * keeping all entries sorted in decreasing order of prefix length.
+ * 1. Search from the last entry up to find the correct slot to insert while
+ *    moving entries one position down to create room.
+ * 2. Insert into empty slot created.
+ *
+ * Subsequently, a linear search down the list can be performed to retrieve a
+ * matching route entry for a Longest Prefix Match.
+ *
+ * @param ip6_prefix the route prefix entry to add.
+ * @param netif pointer to target netif.
+ * @param gateway the gateway address to use to send through. Has to be link local.
+ * @return slot where new entry is entered.
+ */
+s8_t 
+ip6_add_route_entry(struct ip6_prefix *ip6_prefix, struct netif *netif, ip6_addr_t *gateway)
+{
+  int i = -1;
+
+  /* Prefix length cannot be greater than 128 bits */
+  if ((ip6_prefix->prefix_len > 128) || (netif == NULL)) {
+    return ERR_VAL;
+  }
+
+  /* Check if the table is full */
+  if (static_route_table[LWIP_IPV6_NUM_ROUTE_ENTRIES - 1].netif != NULL) {
+    return ERR_MEM;
+  }
+
+  /* Shift all entries down the table until slot is found */
+  for (i = LWIP_IPV6_NUM_ROUTE_ENTRIES - 1;
+       i > 0 && (ip6_prefix->prefix_len > static_route_table[i - 1].prefix.prefix_len); i--) {
+    SMEMCPY(&static_route_table[i], &static_route_table[i - 1], sizeof(struct ip6_route_entry));
+  }
+
+  /* Insert into the empty slot created */
+  SMEMCPY(&static_route_table[i].prefix, ip6_prefix, sizeof(struct ip6_prefix));
+  static_route_table[i].netif = netif;
+  
+  /* Add gateway to route table */
+  if (gateway && ip6_addr_islinklocal(gateway)) {
+    static_route_table[i].gateway = gateway;
+    /* Add gateway to default router list */
+    if (nd6_add_static_gateway(gateway, netif) < 0) {
+      return -1;
+    }
+  }
+  else {
+    static_route_table[i].gateway = NULL;
+  }
+
+  return i;
+}
+
+/**
+ * Removes the route entry from the static route table.
+ *
+ * @param ip6_prefix the route prefix entry to delete.
+ */
+void
+ip6_remove_route_entry(struct ip6_prefix *ip6_prefix)
+{
+  int i, pos = 0;
+  for (i = 0; i < LWIP_IPV6_NUM_ROUTE_ENTRIES; i++) {
+    /* compare prefix to find position to delete */
+    if (ip6_addr_cmp(&ip6_prefix->addr, &static_route_table[i].prefix.addr) &&
+        ip6_prefix->prefix_len == static_route_table[i].prefix.prefix_len) {
+      pos = i;
+      break;
+    }
+
+  }
+
+  /* Shift everything beyond pos one slot up */
+  for (i = pos; i < LWIP_IPV6_NUM_ROUTE_ENTRIES - 1; i++) {
+    SMEMCPY(&static_route_table[i], &static_route_table[i+1], sizeof(struct ip6_route_entry));
+    if (static_route_table[i].netif == NULL) {
+      break;
+    }
+  }
+  /* Set the last entry shifted to NULL; Necessary if table was full */
+  if (i == LWIP_IPV6_NUM_ROUTE_ENTRIES - 1) {
+    static_route_table[LWIP_IPV6_NUM_ROUTE_ENTRIES - 1].netif = NULL;
+  }
+
+  return;
+}
+
+/**
+ * Finds the appropriate route entry in the static route table corresponding to the given
+ * destination IPv6 address. Since the entries in the route table are kept sorted in decreasing
+ * order of prefix length, a linear search down the list is performed to retrieve a matching
+ * index.
+ *
+ * @param ip6_dest_addr the destination address to match
+ * @return the index of the found route entry; -1 if not found.
+ */
+s8_t 
+ip6_find_route_entry(ip6_addr_t *ip6_dest_addr)
+{
+  int i, index = -1;
+
+  /* Search prefix in the sorted(decreasing order of prefix length) list */
+  for(i = 0; i < LWIP_IPV6_NUM_ROUTE_ENTRIES; i++) {
+    if (ip6_addr_cmp_upto_bytenum(ip6_dest_addr, &static_route_table[i].prefix.addr,
+        static_route_table[i].prefix.prefix_len / 8)) {
+      index = i;
+      break;
+    }
+  }
+
+  return index;
+}
+
+/**
+ * Finds the appropriate network interface for a given IPv6 address from a routing table with
+ * static IPv6 routes.
+ *
+ * @param src the source IPv6 address, if known
+ * @param dest the destination IPv6 address for which to find the route
+ * @return the netif on which to send to reach dest
+ */ 
+struct netif *ip6_static_route(ip6_addr_t *src, ip6_addr_t *dest)
+{
+  const int i = ip6_find_route_entry(dest);
+  
+  if (i >= 0) {
+    return static_route_table[i].netif;
+  }
+  else {
+    return NULL;
+  }
+}
+
+/**
+ * Finds the gateway IP6 address for a given destination IPv6 address and target netif
+ * from a routing table with static IPv6 routes.
+ *
+ * @param netif the netif used for sending
+ * @param dest the destination IPv6 address
+ * @return the ip6 address of the gateway to forward packet to
+ */ 
+ip6_addr_t *ip6_get_gateway(struct netif *netif, ip6_addr_t *dest)
+{
+  const int i = ip6_find_route_entry(dest);
+  ip6_addr_t *ret_gw = NULL;
+  
+  if (i >= 0) {
+    if (static_route_table[i].gateway != NULL) {
+      ret_gw = static_route_table[i].gateway;
+    }
+  }
+
+  return ret_gw;
+}
+
+#endif /* LWIP_IPV6_ROUTE_TABLE_SUPPORT */
+
+#endif /* LWIP_IPV6 */
diff --git a/src/core/ipv6/nd6.c b/src/core/ipv6/nd6.c
index c74e35a..811d05b 100644
--- a/src/core/ipv6/nd6.c
+++ b/src/core/ipv6/nd6.c
@@ -1272,6 +1272,56 @@ nd6_is_prefix_in_netif(const ip6_addr_t * ip6addr, struct netif * netif)
   return 0;
 }
 
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+/**
+ * Public method for creating a new destination cache entry. If no unused entry is found,
+ * will recycle oldest entry. 
+ *
+ * @return The destination cache entry index that was created, -1 if no
+ * entry was created
+ */
+s8_t
+nd6_create_destination_cache_entry(void)
+{
+    return nd6_new_destination_cache_entry();
+}
+
+/**
+ * Public method for searching for a destination cache entry
+ *
+ * @param ip6addr the IPv6 address of the destination
+ * @return The destination cache entry index that matched, -1 if no
+ * entry is found
+ */
+s8_t
+nd6_search_destination_cache_entry(ip6_addr_t * ip6addr)
+{
+    return nd6_find_destination_cache_entry(ip6addr);
+}
+
+/**
+ * Add a static gateway to the default router list.
+ *
+ * @param ip6addr the gateway address
+ * @param netif the netif to send the outgoing packet on
+ * @return the default router entry index, or -1 if no suitable
+ *         router is found
+ */
+s8_t
+nd6_add_static_gateway(ip6_addr_t *gateway, struct netif *netif)
+{
+    int i = -1;
+    /* Get the matching default router entry. */
+    i = nd6_get_router(gateway, netif);
+    if (i < 0) {
+      /* Create a new router entry. */
+      i = nd6_new_router(gateway, netif);
+    }
+
+    return i;
+}
+#endif /* LWIP_IPV6_ROUTE_TABLE_SUPPORT */
+
 /**
  * Select a default router for a destination.
  *
diff --git a/src/core/netif.c b/src/core/netif.c
index dbf387c..033a876 100644
--- a/src/core/netif.c
+++ b/src/core/netif.c
@@ -68,6 +68,10 @@
 #include "lwip/mld6.h"
 #endif /* LWIP_IPV6_MLD */
 
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+#include "lwip/ip6_route_table.h"
+#endif /* LWIP_IPV6_ROUTE_TABLE_SUPPORT */
+
 #if LWIP_NETIF_STATUS_CALLBACK
 #define NETIF_STATUS_CALLBACK(n) do{ if (n->status_callback) { (n->status_callback)(n); }}while(0)
 #else
@@ -967,6 +971,9 @@ s8_t
 netif_add_ip6_address(struct netif *netif, ip6_addr_t *ip6addr, s8_t *chosen_idx)
 {
   s8_t i;
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+  struct ip6_prefix ip6_pref;
+#endif
 
   i = netif_get_ip6_addr_match(netif, ip6addr);
   if (i >= 0) {
@@ -979,22 +986,59 @@ netif_add_ip6_address(struct netif *netif, ip6_addr_t *ip6addr, s8_t *chosen_idx
 
   /* Find a free slot -- musn't be the first one (reserved for link local) */
   for (i = 1; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
-    if (!ip6_addr_isvalid(netif->ip6_addr_state[i])) {
+    if (ip6_addr_isinvalid(netif->ip6_addr_state[i])) {
       ip6_addr_copy(netif->ip6_addr[i], *ip6addr);
       netif_ip6_addr_set_state(netif, i, IP6_ADDR_TENTATIVE);
       if (chosen_idx != NULL) {
         *chosen_idx = i;
       }
+  /* Set a /64 route for the newly added address in the route table */
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+      ip6_pref.addr = netif->ip6_addr[i];
+      ip6_pref.prefix_len = 64;
+      if (ip6_add_route_entry(&ip6_pref, netif, NULL) != ERR_OK) {
+        goto fail;
+      }
+#endif
       return ERR_OK;
     }
   }
 
+fail:
   if (chosen_idx != NULL) {
     *chosen_idx = -1;
   }
   return ERR_VAL;
 }
 
+/** This function allows for the easy removal of an IPv6 address from an interface.
+ *
+ * @param netif netif on which the address is assigned
+ * @param ip6addr address to remove
+ */
+s8_t
+netif_remove_ip6_address(struct netif *netif, ip6_addr_t *ip6addr)
+{
+  s8_t i;
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+  struct ip6_prefix ip6_pref;
+#endif
+
+  i = netif_get_ip6_addr_match(netif, ip6addr);
+  if (i >= 0) {
+      ip6_addr_set_zero(netif_ip6_addr(netif, i));
+      netif_ip6_addr_set_state(netif, i, IP6_ADDR_INVALID);
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+      ip6_pref.addr = netif->ip6_addr[i];
+      ip6_pref.prefix_len = 64;
+      ip6_remove_route_entry(&ip6_pref);
+#endif
+    return ERR_OK;
+  }
+
+  return ERR_VAL;
+}
+
 /** Dummy IPv6 output function for netifs not supporting IPv6
  */
 static err_t
diff --git a/src/include/lwip/ip6_route_table.h b/src/include/lwip/ip6_route_table.h
new file mode 100644
index 0000000..b479628
--- /dev/null
+++ b/src/include/lwip/ip6_route_table.h
@@ -0,0 +1,81 @@
+/**
+ * @file
+ *
+ * IPv6 static route table.
+ */
+
+/*
+ * Copyright (c) 2015 Nest Labs, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * Author: Pradip De <pde@nestlabs.com>
+ *
+ *
+ * Please coordinate changes and requests with Pradip De
+ * <pde@nestlabs.com>
+ */
+
+#ifndef __LWIP_IP6_ROUTE_TABLE_H__
+#define __LWIP_IP6_ROUTE_TABLE_H__
+
+#include "lwip/opt.h"
+
+#if LWIP_IPV6  /* don't build if not configured for use in lwipopts.h */
+
+#include "lwip/ip.h"
+#include "lwip/ip6_addr.h"
+#include "lwip/def.h"
+#include "lwip/netif.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+struct ip6_prefix {
+  ip6_addr_t addr;
+  u8_t prefix_len; /* prefix length in bits at byte boundaries */
+};
+
+struct ip6_route_entry {
+  struct ip6_prefix prefix;
+  struct netif *netif;
+  ip6_addr_t *gateway;
+};
+
+s8_t ip6_add_route_entry(struct ip6_prefix *ip6_prefix, struct netif *netif, ip6_addr_t *gateway);
+void ip6_remove_route_entry(struct ip6_prefix *ip6_prefix);
+s8_t ip6_find_route_entry(ip6_addr_t *ip6_dest_addr);
+struct netif *ip6_static_route(ip6_addr_t *src, ip6_addr_t *dest);
+ip6_addr_t *ip6_get_gateway(struct netif *netif, ip6_addr_t *dest);
+#endif /* LWIP_IPV6_ROUTE_TABLE_SUPPORT */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LWIP_IPV6 */
+
+#endif /* __LWIP_IP6_ROUTE_TABLE_H__ */
diff --git a/src/include/lwip/nd6.h b/src/include/lwip/nd6.h
index 5c01d2d..0be0241 100644
--- a/src/include/lwip/nd6.h
+++ b/src/include/lwip/nd6.h
@@ -349,6 +349,12 @@ s8_t nd6_get_next_hop_entry(const ip6_addr_t * ip6addr, struct netif * netif);
 s8_t nd6_select_router(const ip6_addr_t * ip6addr, struct netif * netif);
 u16_t nd6_get_destination_mtu(const ip6_addr_t * ip6addr, struct netif * netif);
 err_t nd6_queue_packet(s8_t neighbor_index, struct pbuf * p);
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+s8_t nd6_create_destination_cache_entry(void);
+s8_t nd6_search_destination_cache_entry(ip6_addr_t * ip6addr);
+s8_t nd6_add_static_gateway(ip6_addr_t *gateway, struct netif *netif);
+#endif
+
 #if LWIP_ND6_TCP_REACHABILITY_HINTS
 void nd6_reachability_hint(const ip6_addr_t * ip6addr);
 #endif /* LWIP_ND6_TCP_REACHABILITY_HINTS */
diff --git a/src/include/lwip/netif.h b/src/include/lwip/netif.h
index 2aea2c2..8c444b0 100644
--- a/src/include/lwip/netif.h
+++ b/src/include/lwip/netif.h
@@ -395,6 +395,7 @@ void netif_poll_all(void);
 s8_t netif_get_ip6_addr_match(struct netif *netif, ip6_addr_t *ip6addr);
 void netif_create_ip6_linklocal_address(struct netif *netif, u8_t from_mac_48bit);
 err_t netif_add_ip6_address(struct netif *netif, ip6_addr_t *ip6addr, s8_t *chosen_idx);
+err_t netif_remove_ip6_address(struct netif *netif, ip6_addr_t *ip6addr);
 #endif /* LWIP_IPV6 */
 
 #if LWIP_NETIF_HWADDRHINT
diff --git a/src/include/lwip/opt.h b/src/include/lwip/opt.h
index d0976e4..e7f7b29 100644
--- a/src/include/lwip/opt.h
+++ b/src/include/lwip/opt.h
@@ -2725,6 +2725,20 @@
 #define LWIP_IPV6_DHCP6                 0
 #endif
 
+/**
+ * LWIP_IPV6_ROUTE_TABLE_SUPPORT==1: Enable support for adding static routes and refering these during forwarding.
+ */
+#ifndef LWIP_IPV6_ROUTE_TABLE_SUPPORT
+#define LWIP_IPV6_ROUTE_TABLE_SUPPORT   0
+#endif
+
+/**
+ * LWIP_IPV6_NUM_ROUTES: Number of IPV6 routes that can be kept in the static route table.
+ */
+#ifndef LWIP_IPV6_NUM_ROUTE_ENTRIES
+#define LWIP_IPV6_NUM_ROUTE_ENTRIES     8
+#endif
+
 /*
    ---------------------------------------
    ---------- Hook options ---------------
@@ -2786,6 +2800,22 @@
  * Returns the destination netif or NULL if no destination netif is found. In
  * that case, ip6_route() continues as normal.
  */
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+#define LWIP_HOOK_IP6_ROUTE(src, dest)               ip6_static_route(src, dest)
+#endif
+
+/**
+* LWIP_HOOK_ETHIP6_GET_GW(netif, dest):
+* - called from ethip6_output() (IPv6)
+* - netif: the netif used for sending
+* - dest: the destination IPv6 address
+* Returns the IPv6 address of the gateway to handle the specified destination
+* IPv6 address. If NULL is returned, the netif's default gateway is used.
+* The returned address MUST be reachable on the specified netif!
+*/
+#if LWIP_IPV6_ROUTE_TABLE_SUPPORT
+#define LWIP_HOOK_ETHIP6_GET_GW(netif, dest)         ip6_get_gateway(netif, dest)
+#endif
 
 /**
  * LWIP_HOOK_VLAN_CHECK(netif, eth_hdr, vlan_hdr):
