diff --git a/menu/drivers_display/menu_display_d3d.c b/menu/drivers_display/menu_display_d3d.c
new file mode 100644
index 0000000000..6305645249
--- /dev/null
+++ b/menu/drivers_display/menu_display_d3d.c
@@ -0,0 +1,243 @@
+/* RetroArch - A frontend for libretro.
+ * Copyright (C) 2011-2015 - Daniel De Matteis
+ *
+ * RetroArch is free software: you can redistribute it and/or modify it under the terms
+ * of the GNU General Public License as published by the Free Software Found-
+ * ation, either version 3 of the License, or (at your option) any later version.
+ *
+ * RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ * PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with RetroArch.
+ * If not, see .
+ */
+
+#include
+
+#include
+#include
+
+#include "../../config.def.h"
+#include "../../gfx/font_renderer_driver.h"
+#include "../../gfx/video_context_driver.h"
+#include "../../gfx/video_thread_wrapper.h"
+#include "../../gfx/video_texture.h"
+#include "../../gfx/d3d/d3d.h"
+#include "../../gfx/d3d/d3d_wrapper.h"
+
+#include "../menu_display.h"
+
+static const float gl_vertexes[] = {
+ 0, 0,
+ 1, 0,
+ 0, 1,
+ 1, 1
+};
+
+static const float gl_tex_coords[] = {
+ 0, 1,
+ 1, 1,
+ 0, 0,
+ 1, 0
+};
+
+static void *menu_display_d3d_get_default_mvp(void)
+{
+ d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
+
+ if (!d3d)
+ return NULL;
+
+ return &d3d->mvp_no_rot;
+}
+
+static GLenum menu_display_prim_to_d3d_enum(enum menu_display_prim_type prim_type)
+{
+ switch (prim_type)
+ {
+ case MENU_DISPLAY_PRIM_TRIANGLES:
+ case MENU_DISPLAY_PRIM_TRIANGLESTRIP:
+ return D3DPT_TRIANGLESTRIP;
+ case MENU_DISPLAY_PRIM_NONE:
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+static void menu_display_d3d_blend_begin(void)
+{
+ d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
+
+ if (!d3d)
+ return;
+
+ d3d_enable_blend_func(d3d->dev);
+
+#if 0
+ if (gl->shader && gl->shader->use)
+ gl->shader->use(gl, GL_SHADER_STOCK_BLEND);
+#endif
+}
+
+static void menu_display_d3d_blend_end(void)
+{
+ d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
+
+ if (!d3d)
+ return;
+
+ d3d_disable_blend_func(d3d->dev);
+}
+
+static void menu_display_d3d_draw(
+ unsigned x, unsigned y,
+ unsigned width, unsigned height,
+ struct gfx_coords *coords,
+ void *matrix_data,
+ uintptr_t texture,
+ enum menu_display_prim_type prim_type
+ )
+{
+ D3DVIEWPORT vp = {0};
+ driver_t *driver = driver_get_ptr();
+ d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
+ math_matrix_4x4 *mat = (math_matrix_4x4*)matrix_data;
+
+ if (!d3d)
+ return;
+
+ /* TODO - edge case */
+ if (height <= 0)
+ height = 1;
+
+ if (!mat)
+ mat = &gl->mvp_no_rot;
+ if (!coords->vertex)
+ coords->vertex = &gl_vertexes[0];
+ if (!coords->tex_coord)
+ coords->tex_coord = &gl_tex_coords[0];
+ if (!coords->lut_tex_coord)
+ coords->lut_tex_coord = &gl_tex_coords[0];
+
+ vp.X = x;
+ vp.Y = y;
+ vp.Width = width;
+ vp.Height = height;
+ vp.MinZ = 0.0f;
+ vp.MaxZ = 1.0f;
+
+ d3d_set_viewport(d3d->dev, &vp);
+ d3d_set_texture(d3d->dev, 0, texture);
+
+#if 0
+ gl->shader->set_coords(coords);
+ gl->shader->set_mvp(driver->video_data, mat);
+#endif
+
+ d3d_draw_primitive(d3d->dev, menu_display_prim_to_d3d_enum(prim_type), 0, coords->vertices);
+
+ gl->coords.color = gl->white_color_ptr;
+}
+
+static void menu_display_d3d_draw_bg(
+ unsigned width,
+ unsigned height,
+ uintptr_t texture,
+ float handle_alpha,
+ bool force_transparency,
+ GLfloat *coord_color,
+ GLfloat *coord_color2,
+ const float *vertex,
+ const float *tex_coord,
+ size_t vertex_count,
+ enum menu_display_prim_type prim_type)
+{
+ struct gfx_coords coords;
+ const GLfloat *new_vertex = NULL;
+ const GLfloat *new_tex_coord = NULL;
+ global_t *global = global_get_ptr();
+ settings_t *settings = config_get_ptr();
+ gl_t *gl = (gl_t*)video_driver_get_ptr(NULL);
+
+ if (!gl)
+ return;
+
+ new_vertex = vertex;
+ new_tex_coord = tex_coord;
+
+ if (!new_vertex)
+ new_vertex = &gl_vertexes[0];
+ if (!new_tex_coord)
+ new_tex_coord = &gl_tex_coords[0];
+
+ coords.vertices = vertex_count;
+ coords.vertex = new_vertex;
+ coords.tex_coord = new_tex_coord;
+ coords.lut_tex_coord = new_tex_coord;
+ coords.color = (const float*)coord_color;
+
+ menu_display_d3d_blend_begin();
+
+ menu_display_ctl(MENU_DISPLAY_CTL_SET_VIEWPORT, NULL);
+
+ if ((settings->menu.pause_libretro
+ || !global->inited.main || (global->inited.core.type == CORE_TYPE_DUMMY))
+ && !force_transparency
+ && texture)
+ coords.color = (const float*)coord_color2;
+
+ menu_display_d3d_draw(0, 0, width, height,
+ &coords, &gl->mvp_no_rot,
+ (GLuint)texture, prim_type);
+
+ menu_display_d3d_blend_end();
+
+ gl->coords.color = gl->white_color_ptr;
+}
+
+static void menu_display_d3d_restore_clear_color(void)
+{
+ DWORD clear_color = 0x00000000;
+ d3d_clear(d3d->dev, 0, NULL, D3DCLEAR_TARGET, clear_color, 0, 0);
+}
+
+static void menu_display_d3d_clear_color(float r, float g, float b, float a)
+{
+ DWORD clear_color = D3DCOLOR_ARGB(BYTE_CLAMP(a * 255.0f, r * 255.0f, g * 255.0f, b * 255.0f));
+ d3d_clear(d3d->dev, 0, NULL, D3DCLEAR_TARGET, clear_color, 0, 0);
+}
+
+static unsigned menu_display_d3d_texture_load(void *data, enum texture_filter_type type)
+{
+ return video_texture_load(data, TEXTURE_BACKEND_OPENGL, type);
+}
+
+static void menu_display_d3d_texture_unload(uintptr_t *id)
+{
+ if (!id)
+ return;
+ video_texture_unload(id);
+}
+
+static const float *menu_display_d3d_get_tex_coords(void)
+{
+ return &gl_tex_coords[0];
+}
+
+menu_display_ctx_driver_t menu_display_ctx_d3d = {
+ menu_display_d3d_draw,
+ menu_display_d3d_draw_bg,
+ menu_display_d3d_blend_begin,
+ menu_display_d3d_blend_end,
+ menu_display_d3d_restore_clear_color,
+ menu_display_d3d_clear_color,
+ menu_display_d3d_get_default_mvp,
+ menu_display_d3d_get_tex_coords,
+ menu_display_d3d_texture_load,
+ menu_display_d3d_texture_unload,
+ MENU_VIDEO_DRIVER_DIRECT3D,
+ "menu_display_d3d",
+};