diff --git a/flutter/shell/platform/tizen/BUILD.gn b/flutter/shell/platform/tizen/BUILD.gn
index bb52995..17c27ac 100644
--- a/flutter/shell/platform/tizen/BUILD.gn
+++ b/flutter/shell/platform/tizen/BUILD.gn
@@ -115,6 +115,7 @@ template("embedder") {
       "tizen_renderer.cc",
       "tizen_renderer_egl.cc",
       "tizen_renderer_evas_gl.cc",
+      "tizen_renderer_gl.cc",
       "tizen_view_elementary.cc",
       "tizen_vsync_waiter.cc",
       "tizen_window_ecore_wl2.cc",
@@ -171,6 +172,7 @@ template("embedder") {
       sources += [
         "flutter_tizen_nui.cc",
         "tizen_clipboard.cc",
+        "tizen_renderer_nui_gl.cc",
         "tizen_view_nui.cc",
       ]
 
@@ -229,7 +231,7 @@ embedder("flutter_tizen_common") {
 embedder("flutter_tizen_source") {
   target_type = "source_set"
 
-  defines = []
+  defines = [ "UNIT_TESTS" ]
 }
 
 executable("flutter_tizen_unittests") {
diff --git a/flutter/shell/platform/tizen/flutter_tizen.cc b/flutter/shell/platform/tizen/flutter_tizen.cc
index f3faa27..592b03c 100644
--- a/flutter/shell/platform/tizen/flutter_tizen.cc
+++ b/flutter/shell/platform/tizen/flutter_tizen.cc
@@ -214,12 +214,9 @@ FlutterDesktopViewRef FlutterDesktopViewCreateFromNewWindow(
 
   auto view = std::make_unique<flutter::FlutterTizenView>(
       flutter::kImplicitViewId, std::move(window),
-      window_properties.user_pixel_ratio);
+      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)),
+      window_properties.renderer_type, window_properties.user_pixel_ratio);
 
-  // Take ownership of the engine, starting it if necessary.
-  view->SetEngine(
-      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)));
-  view->CreateRenderSurface(window_properties.renderer_type);
   if (!view->engine()->IsRunning()) {
     if (!view->engine()->RunEngine()) {
       return nullptr;
diff --git a/flutter/shell/platform/tizen/flutter_tizen_elementary.cc b/flutter/shell/platform/tizen/flutter_tizen_elementary.cc
index c5640ce..c7bf405 100644
--- a/flutter/shell/platform/tizen/flutter_tizen_elementary.cc
+++ b/flutter/shell/platform/tizen/flutter_tizen_elementary.cc
@@ -31,12 +31,10 @@ FlutterDesktopViewRef FlutterDesktopViewCreateFromElmParent(
           static_cast<Evas_Object*>(parent));
 
   auto view = std::make_unique<flutter::FlutterTizenView>(
-      flutter::kImplicitViewId, std::move(tizen_view));
+      flutter::kImplicitViewId, std::move(tizen_view),
+      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)),
+      FlutterDesktopRendererType::kEvasGL);
 
-  // Take ownership of the engine, starting it if necessary.
-  view->SetEngine(
-      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)));
-  view->CreateRenderSurface(FlutterDesktopRendererType::kEvasGL);
   if (!view->engine()->IsRunning()) {
     if (!view->engine()->RunEngine()) {
       return nullptr;
diff --git a/flutter/shell/platform/tizen/flutter_tizen_engine.cc b/flutter/shell/platform/tizen/flutter_tizen_engine.cc
index 848b02b..769c273 100644
--- a/flutter/shell/platform/tizen/flutter_tizen_engine.cc
+++ b/flutter/shell/platform/tizen/flutter_tizen_engine.cc
@@ -19,6 +19,11 @@
 #include "flutter/shell/platform/tizen/tizen_renderer_egl.h"
 #include "flutter/shell/platform/tizen/tizen_renderer_evas_gl.h"
 
+#ifdef NUI_SUPPORT
+#include "flutter/shell/platform/tizen/tizen_renderer_nui_gl.h"
+#include "flutter/shell/platform/tizen/tizen_view_nui.h"
+#endif
+
 namespace flutter {
 
 namespace {
@@ -79,23 +84,21 @@ FlutterTizenEngine::~FlutterTizenEngine() {
   StopEngine();
 }
 
-void FlutterTizenEngine::CreateRenderer(
+std::unique_ptr<TizenRenderer> FlutterTizenEngine::CreateRenderer(
     FlutterDesktopRendererType renderer_type) {
-  if (renderer_type == FlutterDesktopRendererType::kEvasGL) {
-    renderer_ = std::make_unique<TizenRendererEvasGL>();
-
-    render_loop_ = std::make_unique<TizenRenderEventLoop>(
-        std::this_thread::get_id(),  // main thread
-        embedder_api_.GetCurrentTime,
-        [this](const auto* task) {
-          if (embedder_api_.RunTask(this->engine_, task) != kSuccess) {
-            FT_LOG(Error) << "Could not post an engine task.";
-          }
-        },
-        renderer_.get());
-  } else {
-    renderer_ = std::make_unique<TizenRendererEgl>(
-        project_->HasArgument("--enable-impeller"));
+  switch (renderer_type) {
+    case FlutterDesktopRendererType::kEvasGL:
+      return std::make_unique<TizenRendererEvasGL>(view_->tizen_view());
+    case FlutterDesktopRendererType::kEGL:
+#ifdef NUI_SUPPORT
+      if (auto* nui_view =
+              dynamic_cast<flutter::TizenViewNui*>(view_->tizen_view())) {
+        return std::make_unique<TizenRendererNuiGL>(
+            nui_view, project_->HasArgument("--enable-impeller"));
+      }
+#endif
+      return std::make_unique<TizenRendererEgl>(
+          view_->tizen_view(), project_->HasArgument("--enable-impeller"));
   }
 }
 
@@ -244,8 +247,7 @@ bool FlutterTizenEngine::RunEngine() {
       internal_plugin_registrar_->messenger());
 
   if (IsHeaded()) {
-    texture_registrar_ = std::make_unique<FlutterTizenTextureRegistrar>(
-        this, project_->HasArgument("--enable-impeller"));
+    texture_registrar_ = std::make_unique<FlutterTizenTextureRegistrar>(this);
     keyboard_channel_ = std::make_unique<KeyboardChannel>(
         internal_plugin_registrar_->messenger(),
         [this](const FlutterKeyEvent& event, FlutterKeyEventCallback callback,
@@ -294,8 +296,22 @@ bool FlutterTizenEngine::StopEngine() {
   return false;
 }
 
-void FlutterTizenEngine::SetView(FlutterTizenView* view) {
+void FlutterTizenEngine::SetView(FlutterTizenView* view,
+                                 FlutterDesktopRendererType renderer_type) {
   view_ = view;
+  renderer_ = CreateRenderer(renderer_type);
+
+  if (renderer_type == FlutterDesktopRendererType::kEvasGL) {
+    render_loop_ = std::make_unique<TizenRenderEventLoop>(
+        std::this_thread::get_id(),  // main thread
+        embedder_api_.GetCurrentTime,
+        [this](const auto* task) {
+          if (embedder_api_.RunTask(this->engine_, task) != kSuccess) {
+            FT_LOG(Error) << "Could not post an engine task.";
+          }
+        },
+        renderer_.get());
+  }
 }
 
 void FlutterTizenEngine::AddPluginRegistrarDestructionCallback(
@@ -435,79 +451,17 @@ FlutterDesktopMessage FlutterTizenEngine::ConvertToDesktopMessage(
 }
 
 FlutterRendererConfig FlutterTizenEngine::GetRendererConfig() {
-  FlutterRendererConfig config = {};
   if (IsHeaded()) {
-    config.type = kOpenGL;
-    config.open_gl.struct_size = sizeof(config.open_gl);
-    config.open_gl.make_current = [](void* user_data) -> bool {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return false;
-      }
-      return engine->view()->OnMakeCurrent();
-    };
-    config.open_gl.make_resource_current = [](void* user_data) -> bool {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return false;
-      }
-      return engine->view()->OnMakeResourceCurrent();
-    };
-    config.open_gl.clear_current = [](void* user_data) -> bool {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return false;
-      }
-      return engine->view()->OnClearCurrent();
-    };
-    config.open_gl.present = [](void* user_data) -> bool {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return false;
-      }
-      return engine->view()->OnPresent();
-    };
-    config.open_gl.fbo_callback = [](void* user_data) -> uint32_t {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return false;
-      }
-      return engine->view()->OnGetFBO();
-    };
-    config.open_gl.surface_transformation =
-        [](void* user_data) -> FlutterTransformation {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return FlutterTransformation();
-      }
-      return engine->view()->GetFlutterTransformation();
-    };
-    config.open_gl.gl_proc_resolver = [](void* user_data,
-                                         const char* name) -> void* {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->view()) {
-        return nullptr;
-      }
-      return engine->view()->OnProcResolver(name);
-    };
-    config.open_gl.gl_external_texture_frame_callback =
-        [](void* user_data, int64_t texture_id, size_t width, size_t height,
-           FlutterOpenGLTexture* texture) -> bool {
-      auto* engine = static_cast<FlutterTizenEngine*>(user_data);
-      if (!engine->texture_registrar()) {
-        return false;
-      }
-      return engine->texture_registrar()->PopulateTexture(texture_id, width,
-                                                          height, texture);
-    };
+    return renderer()->GetRendererConfig();
   } else {
+    FlutterRendererConfig config = {};
     config.type = kSoftware;
     config.software.struct_size = sizeof(config.software);
     config.software.surface_present_callback =
         [](void* user_data, const void* allocation, size_t row_bytes,
            size_t height) -> bool { return true; };
+    return config;
   }
-  return config;
 }
 
 void FlutterTizenEngine::DispatchAccessibilityAction(
diff --git a/flutter/shell/platform/tizen/flutter_tizen_engine.h b/flutter/shell/platform/tizen/flutter_tizen_engine.h
index 5d995c5..00ace31 100644
--- a/flutter/shell/platform/tizen/flutter_tizen_engine.h
+++ b/flutter/shell/platform/tizen/flutter_tizen_engine.h
@@ -63,7 +63,8 @@ class FlutterTizenEngine {
   FlutterTizenEngine& operator=(FlutterTizenEngine const&) = delete;
 
   // Creates a GL renderer from the given type.
-  void CreateRenderer(FlutterDesktopRendererType renderer_type);
+  std::unique_ptr<TizenRenderer> CreateRenderer(
+      FlutterDesktopRendererType renderer_type);
 
   // Starts running the engine with the given entrypoint. If null, defaults to
   // main().
@@ -78,7 +79,8 @@ class FlutterTizenEngine {
   bool StopEngine();
 
   // Sets the view that is displaying this engine's content.
-  void SetView(FlutterTizenView* view);
+  void SetView(FlutterTizenView* view,
+               FlutterDesktopRendererType renderer_type);
 
   // The view displaying this engine's content, if any. This will be null for
   // headless engines.
diff --git a/flutter/shell/platform/tizen/flutter_tizen_nui.cc b/flutter/shell/platform/tizen/flutter_tizen_nui.cc
index 74fae07..32787e0 100644
--- a/flutter/shell/platform/tizen/flutter_tizen_nui.cc
+++ b/flutter/shell/platform/tizen/flutter_tizen_nui.cc
@@ -40,12 +40,10 @@ FlutterDesktopViewRef FlutterDesktopViewCreateFromImageView(
           default_window_id);
 
   auto view = std::make_unique<flutter::FlutterTizenView>(
-      flutter::kImplicitViewId, std::move(tizen_view));
+      flutter::kImplicitViewId, std::move(tizen_view),
+      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)),
+      FlutterDesktopRendererType::kEGL);
 
-  // Take ownership of the engine, starting it if necessary.
-  view->SetEngine(
-      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)));
-  view->CreateRenderSurface(FlutterDesktopRendererType::kEGL);
   if (!view->engine()->IsRunning()) {
     if (!view->engine()->RunEngine()) {
       return nullptr;
diff --git a/flutter/shell/platform/tizen/flutter_tizen_texture_registrar.cc b/flutter/shell/platform/tizen/flutter_tizen_texture_registrar.cc
index a3b4181..b189d26 100644
--- a/flutter/shell/platform/tizen/flutter_tizen_texture_registrar.cc
+++ b/flutter/shell/platform/tizen/flutter_tizen_texture_registrar.cc
@@ -20,9 +20,8 @@
 namespace flutter {
 
 FlutterTizenTextureRegistrar::FlutterTizenTextureRegistrar(
-    FlutterTizenEngine* engine,
-    bool enable_impeller)
-    : engine_(engine), enable_impeller_(enable_impeller) {}
+    FlutterTizenEngine* engine)
+    : engine_(engine) {}
 
 int64_t FlutterTizenTextureRegistrar::RegisterTexture(
     const FlutterDesktopTextureInfo* texture_info) {
@@ -45,12 +44,19 @@ int64_t FlutterTizenTextureRegistrar::RegisterTexture(
       return -1;
     }
   }
-  FlutterDesktopRendererType renderer_type = FlutterDesktopRendererType::kEGL;
-  if (dynamic_cast<TizenRendererEvasGL*>(engine_->renderer())) {
-    renderer_type = FlutterDesktopRendererType::kEvasGL;
+  std::unique_ptr<ExternalTexture> texture_gl = nullptr;
+
+#ifndef UNIT_TESTS
+  if (engine_->renderer()) {
+    texture_gl = engine_->renderer()->CreateExternalTexture(texture_info);
   }
-  std::unique_ptr<ExternalTexture> texture_gl =
-      CreateExternalTexture(texture_info, renderer_type);
+#else
+  texture_gl = std::make_unique<ExternalTextureSurfaceEGL>(
+      ExternalTextureExtensionType::kDmaBuffer,
+      texture_info->gpu_surface_config.callback,
+      texture_info->gpu_surface_config.user_data);
+#endif
+
   if (!texture_gl) {
     FT_LOG(Error) << "Failed to create ExternalTexture.";
     return -1;
@@ -100,52 +106,4 @@ bool FlutterTizenTextureRegistrar::PopulateTexture(
   return texture->PopulateTexture(width, height, opengl_texture);
 }
 
-std::unique_ptr<ExternalTexture>
-FlutterTizenTextureRegistrar::CreateExternalTexture(
-    const FlutterDesktopTextureInfo* texture_info,
-    FlutterDesktopRendererType renderer_type) {
-  switch (texture_info->type) {
-    case kFlutterDesktopPixelBufferTexture:
-      if (renderer_type == FlutterDesktopRendererType::kEvasGL) {
-        return std::make_unique<ExternalTexturePixelEvasGL>(
-            texture_info->pixel_buffer_config.callback,
-            texture_info->pixel_buffer_config.user_data);
-      }
-      if (enable_impeller_) {
-        return std::make_unique<ExternalTexturePixelEGLImpeller>(
-            texture_info->pixel_buffer_config.callback,
-            texture_info->pixel_buffer_config.user_data);
-      } else {
-        return std::make_unique<ExternalTexturePixelEGL>(
-            texture_info->pixel_buffer_config.callback,
-            texture_info->pixel_buffer_config.user_data);
-      }
-    case kFlutterDesktopGpuSurfaceTexture:
-      ExternalTextureExtensionType gl_extension =
-          ExternalTextureExtensionType::kNone;
-      if (engine_->renderer() && engine_->renderer()->IsSupportedExtension(
-                                     "EGL_TIZEN_image_native_surface")) {
-        gl_extension = ExternalTextureExtensionType::kNativeSurface;
-      } else if (engine_->renderer() &&
-                 engine_->renderer()->IsSupportedExtension(
-                     "EGL_EXT_image_dma_buf_import")) {
-        gl_extension = ExternalTextureExtensionType::kDmaBuffer;
-      }
-      if (renderer_type == FlutterDesktopRendererType::kEvasGL) {
-        return std::make_unique<ExternalTextureSurfaceEvasGL>(
-            gl_extension, texture_info->gpu_surface_config.callback,
-            texture_info->gpu_surface_config.user_data);
-      }
-      if (enable_impeller_) {
-        return std::make_unique<ExternalTextureSurfaceEGLImpeller>(
-            gl_extension, texture_info->gpu_surface_config.callback,
-            texture_info->gpu_surface_config.user_data);
-      } else {
-        return std::make_unique<ExternalTextureSurfaceEGL>(
-            gl_extension, texture_info->gpu_surface_config.callback,
-            texture_info->gpu_surface_config.user_data);
-      }
-  }
-}
-
 }  // namespace flutter
diff --git a/flutter/shell/platform/tizen/flutter_tizen_texture_registrar.h b/flutter/shell/platform/tizen/flutter_tizen_texture_registrar.h
index a56976e..cc2482c 100644
--- a/flutter/shell/platform/tizen/flutter_tizen_texture_registrar.h
+++ b/flutter/shell/platform/tizen/flutter_tizen_texture_registrar.h
@@ -20,8 +20,7 @@ class FlutterTizenEngine;
 // Thread safety: All member methods are thread safe.
 class FlutterTizenTextureRegistrar {
  public:
-  explicit FlutterTizenTextureRegistrar(FlutterTizenEngine* engine,
-                                        bool enable_impeller);
+  explicit FlutterTizenTextureRegistrar(FlutterTizenEngine* engine);
 
   // Registers a texture described by the given |texture_info| object.
   //
@@ -47,17 +46,12 @@ class FlutterTizenTextureRegistrar {
                        size_t height,
                        FlutterOpenGLTexture* texture);
 
-  std::unique_ptr<ExternalTexture> CreateExternalTexture(
-      const FlutterDesktopTextureInfo* info,
-      FlutterDesktopRendererType renderer_type);
-
  private:
   FlutterTizenEngine* engine_ = nullptr;
 
   // All registered textures, keyed by their IDs.
   std::unordered_map<int64_t, std::unique_ptr<ExternalTexture>> textures_;
   std::mutex map_mutex_;
-  bool enable_impeller_ = false;
 };
 
 }  // namespace flutter
diff --git a/flutter/shell/platform/tizen/flutter_tizen_texture_registrar_unittests.cc b/flutter/shell/platform/tizen/flutter_tizen_texture_registrar_unittests.cc
index 0f9d156..f757c4c 100644
--- a/flutter/shell/platform/tizen/flutter_tizen_texture_registrar_unittests.cc
+++ b/flutter/shell/platform/tizen/flutter_tizen_texture_registrar_unittests.cc
@@ -43,7 +43,7 @@ class FlutterTizenTextureRegistrarTest : public ::testing::Test {
 };
 
 TEST_F(FlutterTizenTextureRegistrarTest, CreateDestroy) {
-  FlutterTizenTextureRegistrar registrar(engine_, false);
+  FlutterTizenTextureRegistrar registrar(engine_);
 
   EXPECT_TRUE(true);
 }
@@ -51,7 +51,7 @@ TEST_F(FlutterTizenTextureRegistrarTest, CreateDestroy) {
 TEST_F(FlutterTizenTextureRegistrarTest, RegisterUnregisterTexture) {
   EngineModifier modifier(engine_);
 
-  FlutterTizenTextureRegistrar registrar(engine_, false);
+  FlutterTizenTextureRegistrar registrar(engine_);
 
   FlutterDesktopTextureInfo texture_info = {};
   texture_info.type = kFlutterDesktopGpuSurfaceTexture;
@@ -105,7 +105,7 @@ TEST_F(FlutterTizenTextureRegistrarTest, RegisterUnregisterTexture) {
 TEST_F(FlutterTizenTextureRegistrarTest, RegisterUnknownTextureType) {
   EngineModifier modifier(engine_);
 
-  FlutterTizenTextureRegistrar registrar(engine_, false);
+  FlutterTizenTextureRegistrar registrar(engine_);
 
   FlutterDesktopTextureInfo texture_info = {};
   texture_info.type = static_cast<FlutterDesktopTextureType>(1234);
@@ -116,7 +116,7 @@ TEST_F(FlutterTizenTextureRegistrarTest, RegisterUnknownTextureType) {
 }
 
 TEST_F(FlutterTizenTextureRegistrarTest, PopulateInvalidTexture) {
-  FlutterTizenTextureRegistrar registrar(engine_, false);
+  FlutterTizenTextureRegistrar registrar(engine_);
 
   bool result = registrar.PopulateTexture(1, 640, 480, nullptr);
   EXPECT_FALSE(result);
diff --git a/flutter/shell/platform/tizen/flutter_tizen_view.cc b/flutter/shell/platform/tizen/flutter_tizen_view.cc
index 11028e3..2dddeb6 100644
--- a/flutter/shell/platform/tizen/flutter_tizen_view.cc
+++ b/flutter/shell/platform/tizen/flutter_tizen_view.cc
@@ -44,11 +44,16 @@ namespace flutter {
 
 FlutterTizenView::FlutterTizenView(FlutterViewId view_id,
                                    std::unique_ptr<TizenViewBase> tizen_view,
+                                   std::unique_ptr<FlutterTizenEngine> engine,
+                                   FlutterDesktopRendererType renderer_type,
                                    double user_pixel_ratio)
     : view_id_(view_id),
       tizen_view_(std::move(tizen_view)),
+      engine_(std::move(engine)),
       user_pixel_ratio_(user_pixel_ratio) {
   tizen_view_->SetView(this);
+  engine_->SetView(this, renderer_type);
+  SetupChannels();
 
   if (auto* window = dynamic_cast<TizenWindow*>(tizen_view_.get())) {
     window->BindKeys(kBindableSystemKeys);
@@ -62,17 +67,12 @@ FlutterTizenView::~FlutterTizenView() {
     }
     engine_->StopEngine();
   }
-  DestroyRenderSurface();
 }
 
-void FlutterTizenView::SetEngine(std::unique_ptr<FlutterTizenEngine> engine) {
-  engine_ = std::move(engine);
-  engine_->SetView(this);
-
+void FlutterTizenView::SetupChannels() {
   internal_plugin_registrar_ =
       std::make_unique<PluginRegistrar>(engine_->plugin_registrar());
 
-  // Set up window dependent channels.
   BinaryMessenger* messenger = internal_plugin_registrar_->messenger();
 
   auto* window = dynamic_cast<TizenWindow*>(tizen_view_.get());
@@ -98,33 +98,6 @@ void FlutterTizenView::SetEngine(std::unique_ptr<FlutterTizenEngine> engine) {
   input_device_channel_ = std::make_unique<InputDeviceChannel>(messenger);
 }
 
-void FlutterTizenView::CreateRenderSurface(
-    FlutterDesktopRendererType renderer_type) {
-  if (engine_) {
-    engine_->CreateRenderer(renderer_type);
-  }
-
-  if (engine_ && engine_->renderer()) {
-    TizenGeometry geometry = tizen_view_->GetGeometry();
-    if (dynamic_cast<TizenWindow*>(tizen_view_.get())) {
-      auto* window = dynamic_cast<TizenWindow*>(tizen_view_.get());
-      engine_->renderer()->CreateSurface(window->GetRenderTarget(),
-                                         window->GetRenderTargetDisplay(),
-                                         geometry.width, geometry.height);
-    } else {
-      auto* tizen_view = dynamic_cast<TizenView*>(tizen_view_.get());
-      engine_->renderer()->CreateSurface(tizen_view->GetRenderTarget(), nullptr,
-                                         geometry.width, geometry.height);
-    }
-  }
-}
-
-void FlutterTizenView::DestroyRenderSurface() {
-  if (engine_ && engine_->renderer()) {
-    engine_->renderer()->DestroySurface();
-  }
-}
-
 void FlutterTizenView::Resize(int32_t width, int32_t height) {
   TizenGeometry geometry = tizen_view_->GetGeometry();
   geometry.width = width;
@@ -132,37 +105,6 @@ void FlutterTizenView::Resize(int32_t width, int32_t height) {
   tizen_view_->SetGeometry(geometry);
 }
 
-bool FlutterTizenView::OnMakeCurrent() {
-  return engine_->renderer()->OnMakeCurrent();
-}
-
-bool FlutterTizenView::OnClearCurrent() {
-  return engine_->renderer()->OnClearCurrent();
-}
-
-bool FlutterTizenView::OnMakeResourceCurrent() {
-  return engine_->renderer()->OnMakeResourceCurrent();
-}
-
-bool FlutterTizenView::OnPresent() {
-  bool result = engine_->renderer()->OnPresent();
-#ifdef NUI_SUPPORT
-  if (auto* nui_view =
-          dynamic_cast<flutter::TizenViewNui*>(tizen_view_.get())) {
-    nui_view->RequestRendering();
-  }
-#endif
-  return result;
-}
-
-uint32_t FlutterTizenView::OnGetFBO() {
-  return engine_->renderer()->OnGetFBO();
-}
-
-void* FlutterTizenView::OnProcResolver(const char* name) {
-  return engine_->renderer()->OnProcResolver(name);
-}
-
 void FlutterTizenView::OnResize(int32_t left,
                                 int32_t top,
                                 int32_t width,
diff --git a/flutter/shell/platform/tizen/flutter_tizen_view.h b/flutter/shell/platform/tizen/flutter_tizen_view.h
index de4f07b..1d3d0ac 100644
--- a/flutter/shell/platform/tizen/flutter_tizen_view.h
+++ b/flutter/shell/platform/tizen/flutter_tizen_view.h
@@ -27,6 +27,8 @@ class FlutterTizenView : public TizenViewEventHandlerDelegate {
  public:
   FlutterTizenView(FlutterViewId view_id,
                    std::unique_ptr<TizenViewBase> tizen_view,
+                   std::unique_ptr<FlutterTizenEngine> engine,
+                   FlutterDesktopRendererType renderer_type,
                    double user_pixel_ratio = 0);
 
   virtual ~FlutterTizenView();
@@ -34,34 +36,15 @@ class FlutterTizenView : public TizenViewEventHandlerDelegate {
   // Get the view's unique identifier.
   FlutterViewId view_id() const { return view_id_; }
 
-  // Configures the window instance with an instance of a running Flutter
-  // engine.
-  void SetEngine(std::unique_ptr<FlutterTizenEngine> engine);
+  // Set up window dependent channels.
+  void SetupChannels();
 
   FlutterTizenEngine* engine() { return engine_.get(); }
 
   TizenViewBase* tizen_view() { return tizen_view_.get(); }
 
-  // Creates rendering surface for Flutter engine to draw into.
-  // Should be called before calling FlutterEngineRun using this view.
-  void CreateRenderSurface(FlutterDesktopRendererType renderer_type);
-
-  // Destroys current rendering surface if one has been allocated.
-  void DestroyRenderSurface();
-
   void Resize(int32_t width, int32_t height);
 
-  // Callbacks for clearing context, settings context and swapping buffers,
-  // these are typically called on an engine-controlled (non-platform) thread.
-  bool OnMakeCurrent();
-  bool OnClearCurrent();
-  bool OnMakeResourceCurrent();
-  bool OnPresent();
-
-  uint32_t OnGetFBO();
-
-  void* OnProcResolver(const char* name);
-
   void OnResize(int32_t left,
                 int32_t top,
                 int32_t width,
@@ -172,15 +155,15 @@ class FlutterTizenView : public TizenViewEventHandlerDelegate {
                                size_t timestamp,
                                PointerState* state);
 
-  // The engine associated with this view.
-  std::unique_ptr<FlutterTizenEngine> engine_;
-
   // The view's unique identifier.
   FlutterViewId view_id_;
 
   // The platform view associated with this Flutter view.
   std::unique_ptr<TizenViewBase> tizen_view_;
 
+  // The engine associated with this view.
+  std::unique_ptr<FlutterTizenEngine> engine_;
+
   // Keeps track of pointer states.
   std::unordered_map<int32_t, std::unique_ptr<PointerState>> pointer_states_;
 
diff --git a/flutter/shell/platform/tizen/tizen_renderer.cc b/flutter/shell/platform/tizen/tizen_renderer.cc
index f37732b..52586e1 100644
--- a/flutter/shell/platform/tizen/tizen_renderer.cc
+++ b/flutter/shell/platform/tizen/tizen_renderer.cc
@@ -2,12 +2,30 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "tizen_renderer.h"
+#include "flutter/shell/platform/tizen/tizen_renderer.h"
+#include "flutter/shell/platform/tizen/flutter_tizen_engine.h"
+#include "flutter/shell/platform/tizen/tizen_view.h"
+#include "flutter/shell/platform/tizen/tizen_view_base.h"
+#include "flutter/shell/platform/tizen/tizen_window.h"
 
 namespace flutter {
 
 TizenRenderer::TizenRenderer() {}
 
+bool TizenRenderer::CreateSurface(TizenViewBase* view) {
+  TizenGeometry geometry = view->GetGeometry();
+  if (dynamic_cast<TizenWindow*>(view)) {
+    auto* window = dynamic_cast<TizenWindow*>(view);
+    return CreateSurface(window->GetRenderTarget(),
+                         window->GetRenderTargetDisplay(), geometry.width,
+                         geometry.height);
+  } else {
+    auto* tizen_view = dynamic_cast<TizenView*>(view);
+    return CreateSurface(tizen_view->GetRenderTarget(), nullptr, geometry.width,
+                         geometry.height);
+  }
+}
+
 TizenRenderer::~TizenRenderer() = default;
 
 }  // namespace flutter
diff --git a/flutter/shell/platform/tizen/tizen_renderer.h b/flutter/shell/platform/tizen/tizen_renderer.h
index 1077b17..3fbf36d 100644
--- a/flutter/shell/platform/tizen/tizen_renderer.h
+++ b/flutter/shell/platform/tizen/tizen_renderer.h
@@ -6,6 +6,9 @@
 #define EMBEDDER_TIZEN_RENDERER_H_
 
 #include <cstdint>
+#include "flutter/shell/platform/embedder/embedder.h"
+#include "flutter/shell/platform/tizen/external_texture.h"
+#include "flutter/shell/platform/tizen/tizen_view_base.h"
 
 namespace flutter {
 
@@ -14,33 +17,21 @@ class TizenRenderer {
   TizenRenderer();
 
   virtual ~TizenRenderer();
+  bool IsValid() { return is_valid_; }
+
+  virtual void ResizeSurface(int32_t width, int32_t height) = 0;
 
+  virtual FlutterRendererConfig GetRendererConfig() = 0;
+  virtual std::unique_ptr<ExternalTexture> CreateExternalTexture(
+      const FlutterDesktopTextureInfo* texture_info) = 0;
+
+ protected:
+  bool CreateSurface(TizenViewBase* view);
   virtual bool CreateSurface(void* render_target,
                              void* render_target_display,
                              int32_t width,
                              int32_t height) = 0;
-
   virtual void DestroySurface() = 0;
-
-  bool IsValid() { return is_valid_; }
-
-  virtual bool OnMakeCurrent() = 0;
-
-  virtual bool OnClearCurrent() = 0;
-
-  virtual bool OnMakeResourceCurrent() = 0;
-
-  virtual bool OnPresent() = 0;
-
-  virtual uint32_t OnGetFBO() = 0;
-
-  virtual void* OnProcResolver(const char* name) = 0;
-
-  virtual bool IsSupportedExtension(const char* name) = 0;
-
-  virtual void ResizeSurface(int32_t width, int32_t height) = 0;
-
- protected:
   bool is_valid_ = false;
 };
 
diff --git a/flutter/shell/platform/tizen/tizen_renderer_egl.cc b/flutter/shell/platform/tizen/tizen_renderer_egl.cc
index 2379395..15c041b 100644
--- a/flutter/shell/platform/tizen/tizen_renderer_egl.cc
+++ b/flutter/shell/platform/tizen/tizen_renderer_egl.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "tizen_renderer_egl.h"
+#include "flutter/shell/platform/tizen/tizen_renderer_egl.h"
 
 #define EFL_BETA_API_SUPPORT
 #include <Ecore_Wl2.h>
@@ -15,17 +15,52 @@
 #include <tbm_surface.h>
 #include <tbm_surface_queue.h>
 
+#include "flutter/shell/platform/tizen/external_texture_pixel_egl.h"
+#include "flutter/shell/platform/tizen/external_texture_pixel_egl_impeller.h"
+#include "flutter/shell/platform/tizen/external_texture_surface_egl.h"
+#include "flutter/shell/platform/tizen/external_texture_surface_egl_impeller.h"
 #include "flutter/shell/platform/tizen/logger.h"
 
 namespace flutter {
 
-TizenRendererEgl::TizenRendererEgl(bool enable_impeller)
-    : enable_impeller_(enable_impeller) {}
+TizenRendererEgl::TizenRendererEgl(TizenViewBase* view_base,
+                                   bool enable_impeller)
+    : enable_impeller_(enable_impeller) {
+  TizenRenderer::CreateSurface(view_base);
+}
 
 TizenRendererEgl::~TizenRendererEgl() {
   DestroySurface();
 }
 
+std::unique_ptr<ExternalTexture> TizenRendererEgl::CreateExternalTexture(
+    const FlutterDesktopTextureInfo* texture_info) {
+  switch (texture_info->type) {
+    case kFlutterDesktopPixelBufferTexture:
+      if (enable_impeller_) {
+        return std::make_unique<ExternalTexturePixelEGLImpeller>(
+            texture_info->pixel_buffer_config.callback,
+            texture_info->pixel_buffer_config.user_data);
+      } else {
+        return std::make_unique<ExternalTexturePixelEGL>(
+            texture_info->pixel_buffer_config.callback,
+            texture_info->pixel_buffer_config.user_data);
+      }
+    case kFlutterDesktopGpuSurfaceTexture:
+      if (enable_impeller_) {
+        return std::make_unique<ExternalTextureSurfaceEGLImpeller>(
+            GetExternalTextureExtensionType(),
+            texture_info->gpu_surface_config.callback,
+            texture_info->gpu_surface_config.user_data);
+      } else {
+        return std::make_unique<ExternalTextureSurfaceEGL>(
+            GetExternalTextureExtensionType(),
+            texture_info->gpu_surface_config.callback,
+            texture_info->gpu_surface_config.user_data);
+      }
+  }
+}
+
 bool TizenRendererEgl::CreateSurface(void* render_target,
                                      void* render_target_display,
                                      int32_t width,
diff --git a/flutter/shell/platform/tizen/tizen_renderer_egl.h b/flutter/shell/platform/tizen/tizen_renderer_egl.h
index cc19ec3..5dadc33 100644
--- a/flutter/shell/platform/tizen/tizen_renderer_egl.h
+++ b/flutter/shell/platform/tizen/tizen_renderer_egl.h
@@ -9,38 +9,45 @@
 
 #include <string>
 
+#include "flutter/shell/platform/tizen/external_texture.h"
 #include "flutter/shell/platform/tizen/tizen_renderer.h"
+#include "flutter/shell/platform/tizen/tizen_renderer_gl.h"
+#include "flutter/shell/platform/tizen/tizen_view_base.h"
 
 namespace flutter {
 
-class TizenRendererEgl : public TizenRenderer {
+class TizenRendererEgl : public TizenRendererGL {
  public:
-  explicit TizenRendererEgl(bool enable_impeller);
+  explicit TizenRendererEgl(TizenViewBase* view_base, bool enable_impeller);
 
   virtual ~TizenRendererEgl();
 
-  bool CreateSurface(void* render_target,
-                     void* render_target_display,
-                     int32_t width,
-                     int32_t height) override;
+  virtual bool OnMakeCurrent() override;
 
-  void DestroySurface() override;
+  virtual bool OnClearCurrent() override;
 
-  bool OnMakeCurrent() override;
+  virtual bool OnMakeResourceCurrent() override;
 
-  bool OnClearCurrent() override;
+  virtual bool OnPresent() override;
 
-  bool OnMakeResourceCurrent() override;
+  virtual uint32_t OnGetFBO() override;
 
-  bool OnPresent() override;
+  virtual void* OnProcResolver(const char* name) override;
 
-  uint32_t OnGetFBO() override;
+  virtual bool IsSupportedExtension(const char* name) override;
 
-  void* OnProcResolver(const char* name) override;
+  virtual void ResizeSurface(int32_t width, int32_t height) override;
 
-  bool IsSupportedExtension(const char* name) override;
+  virtual std::unique_ptr<ExternalTexture> CreateExternalTexture(
+      const FlutterDesktopTextureInfo* texture_info) override;
 
-  void ResizeSurface(int32_t width, int32_t height) override;
+ protected:
+  bool CreateSurface(void* render_target,
+                     void* render_target_display,
+                     int32_t width,
+                     int32_t height) override;
+
+  void DestroySurface() override;
 
  private:
   bool ChooseEGLConfiguration();
diff --git a/flutter/shell/platform/tizen/tizen_renderer_evas_gl.cc b/flutter/shell/platform/tizen/tizen_renderer_evas_gl.cc
index c9e6fc4..4ebb869 100644
--- a/flutter/shell/platform/tizen/tizen_renderer_evas_gl.cc
+++ b/flutter/shell/platform/tizen/tizen_renderer_evas_gl.cc
@@ -4,6 +4,8 @@
 
 #include "tizen_renderer_evas_gl.h"
 
+#include "flutter/shell/platform/tizen/external_texture_pixel_evas_gl.h"
+#include "flutter/shell/platform/tizen/external_texture_surface_evas_gl.h"
 #include "flutter/shell/platform/tizen/logger.h"
 #include "flutter/shell/platform/tizen/tizen_evas_gl_helper.h"
 
@@ -14,12 +16,29 @@ EVAS_GL_GLOBAL_GLES2_DEFINE();
 
 namespace flutter {
 
-TizenRendererEvasGL::TizenRendererEvasGL() {}
+TizenRendererEvasGL::TizenRendererEvasGL(TizenViewBase* view_base) {
+  TizenRenderer::CreateSurface(view_base);
+}
 
 TizenRendererEvasGL::~TizenRendererEvasGL() {
   DestroySurface();
 }
 
+std::unique_ptr<ExternalTexture> TizenRendererEvasGL::CreateExternalTexture(
+    const FlutterDesktopTextureInfo* texture_info) {
+  switch (texture_info->type) {
+    case kFlutterDesktopPixelBufferTexture:
+      return std::make_unique<ExternalTexturePixelEvasGL>(
+          texture_info->pixel_buffer_config.callback,
+          texture_info->pixel_buffer_config.user_data);
+    case kFlutterDesktopGpuSurfaceTexture:
+      return std::make_unique<ExternalTextureSurfaceEvasGL>(
+          GetExternalTextureExtensionType(),
+          texture_info->gpu_surface_config.callback,
+          texture_info->gpu_surface_config.user_data);
+  }
+}
+
 bool TizenRendererEvasGL::CreateSurface(void* render_target,
                                         void* render_target_display,
                                         int32_t width,
diff --git a/flutter/shell/platform/tizen/tizen_renderer_evas_gl.h b/flutter/shell/platform/tizen/tizen_renderer_evas_gl.h
index 3e74627..ff393fa 100644
--- a/flutter/shell/platform/tizen/tizen_renderer_evas_gl.h
+++ b/flutter/shell/platform/tizen/tizen_renderer_evas_gl.h
@@ -9,25 +9,21 @@
 
 #include <Elementary.h>
 
+#include "flutter/shell/platform/tizen/external_texture.h"
 #include "flutter/shell/platform/tizen/tizen_renderer.h"
+#include "flutter/shell/platform/tizen/tizen_renderer_gl.h"
+#include "flutter/shell/platform/tizen/tizen_view_base.h"
 
 namespace flutter {
 
 using OnPixelsDirty = std::function<void()>;
 
-class TizenRendererEvasGL : public TizenRenderer {
+class TizenRendererEvasGL : public TizenRendererGL {
  public:
-  explicit TizenRendererEvasGL();
+  explicit TizenRendererEvasGL(TizenViewBase* view_base);
 
   virtual ~TizenRendererEvasGL();
 
-  bool CreateSurface(void* render_target,
-                     void* render_target_display,
-                     int32_t width,
-                     int32_t height) override;
-
-  void DestroySurface() override;
-
   bool OnMakeCurrent() override;
 
   bool OnClearCurrent() override;
@@ -48,6 +44,17 @@ class TizenRendererEvasGL : public TizenRenderer {
 
   void ResizeSurface(int32_t width, int32_t height) override;
 
+  std::unique_ptr<ExternalTexture> CreateExternalTexture(
+      const FlutterDesktopTextureInfo* info) override;
+
+ protected:
+  bool CreateSurface(void* render_target,
+                     void* render_target_display,
+                     int32_t width,
+                     int32_t height) override;
+
+  void DestroySurface() override;
+
  private:
   Evas_GL* evas_gl_ = nullptr;
   Evas_GL_Config* gl_config_ = nullptr;
diff --git a/flutter/shell/platform/tizen/tizen_renderer_gl.cc b/flutter/shell/platform/tizen/tizen_renderer_gl.cc
new file mode 100644
index 0000000..febc73c
--- /dev/null
+++ b/flutter/shell/platform/tizen/tizen_renderer_gl.cc
@@ -0,0 +1,100 @@
+// Copyright 2025 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/tizen/tizen_renderer_gl.h"
+#include "flutter/shell/platform/tizen/flutter_tizen_engine.h"
+#include "flutter/shell/platform/tizen/flutter_tizen_view.h"
+#include "flutter/shell/platform/tizen/tizen_view.h"
+#include "flutter/shell/platform/tizen/tizen_view_base.h"
+#include "flutter/shell/platform/tizen/tizen_window.h"
+
+namespace flutter {
+
+TizenRendererGL::TizenRendererGL() {}
+
+FlutterRendererConfig TizenRendererGL::GetRendererConfig() {
+  FlutterRendererConfig config = {};
+  config.type = kOpenGL;
+  config.open_gl.struct_size = sizeof(config.open_gl);
+  config.open_gl.make_current = [](void* user_data) -> bool {
+    auto* engine = static_cast<FlutterTizenEngine*>(user_data);
+    if (!engine->view()) {
+      return false;
+    }
+    return dynamic_cast<TizenRendererGL*>(engine->renderer())->OnMakeCurrent();
+  };
+  config.open_gl.make_resource_current = [](void* user_data) -> bool {
+    auto* engine = static_cast<FlutterTizenEngine*>(user_data);
+    if (!engine->view()) {
+      return false;
+    }
+    return dynamic_cast<TizenRendererGL*>(engine->renderer())
+        ->OnMakeResourceCurrent();
+  };
+  config.open_gl.clear_current = [](void* user_data) -> bool {
+    auto* engine = static_cast<FlutterTizenEngine*>(user_data);
+    if (!engine->view()) {
+      return false;
+    }
+    return dynamic_cast<TizenRendererGL*>(engine->renderer())->OnClearCurrent();
+  };
+  config.open_gl.present = [](void* user_data) -> bool {
+    auto* engine = static_cast<FlutterTizenEngine*>(user_data);
+    if (!engine->view()) {
+      return false;
+    }
+    return dynamic_cast<TizenRendererGL*>(engine->renderer())->OnPresent();
+  };
+  config.open_gl.fbo_callback = [](void* user_data) -> uint32_t {
+    auto* engine = static_cast<FlutterTizenEngine*>(user_data);
+    if (!engine->view()) {
+      return false;
+    }
+    return dynamic_cast<TizenRendererGL*>(engine->renderer())->OnGetFBO();
+  };
+  config.open_gl.surface_transformation =
+      [](void* user_data) -> FlutterTransformation {
+    auto* engine = static_cast<FlutterTizenEngine*>(user_data);
+    if (!engine->view()) {
+      return FlutterTransformation();
+    }
+    return engine->view()->GetFlutterTransformation();
+  };
+  config.open_gl.gl_proc_resolver = [](void* user_data,
+                                       const char* name) -> void* {
+    auto* engine = static_cast<FlutterTizenEngine*>(user_data);
+    if (!engine->view()) {
+      return nullptr;
+    }
+    return dynamic_cast<TizenRendererGL*>(engine->renderer())
+        ->OnProcResolver(name);
+  };
+  config.open_gl.gl_external_texture_frame_callback =
+      [](void* user_data, int64_t texture_id, size_t width, size_t height,
+         FlutterOpenGLTexture* texture) -> bool {
+    auto* engine = static_cast<FlutterTizenEngine*>(user_data);
+    if (!engine->texture_registrar()) {
+      return false;
+    }
+    return engine->texture_registrar()->PopulateTexture(texture_id, width,
+                                                        height, texture);
+  };
+  return config;
+}
+
+ExternalTextureExtensionType
+TizenRendererGL::GetExternalTextureExtensionType() {
+  ExternalTextureExtensionType gl_extension =
+      ExternalTextureExtensionType::kNone;
+  if (IsSupportedExtension("EGL_TIZEN_image_native_surface")) {
+    gl_extension = ExternalTextureExtensionType::kNativeSurface;
+  } else if (IsSupportedExtension("EGL_EXT_image_dma_buf_import")) {
+    gl_extension = ExternalTextureExtensionType::kDmaBuffer;
+  }
+  return gl_extension;
+}
+
+TizenRendererGL::~TizenRendererGL() = default;
+
+}  // namespace flutter
diff --git a/flutter/shell/platform/tizen/tizen_renderer_gl.h b/flutter/shell/platform/tizen/tizen_renderer_gl.h
new file mode 100644
index 0000000..ad59a6d
--- /dev/null
+++ b/flutter/shell/platform/tizen/tizen_renderer_gl.h
@@ -0,0 +1,42 @@
+// Copyright 2025 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef EMBEDDER_TIZEN_RENDERER_GL_H_
+#define EMBEDDER_TIZEN_RENDERER_GL_H_
+
+#include <cstdint>
+#include "flutter/shell/platform/embedder/embedder.h"
+#include "flutter/shell/platform/tizen/tizen_renderer.h"
+#include "flutter/shell/platform/tizen/tizen_view_base.h"
+
+namespace flutter {
+
+class TizenRendererGL : public TizenRenderer {
+ public:
+  TizenRendererGL();
+
+  virtual ~TizenRendererGL();
+
+  virtual bool OnMakeCurrent() = 0;
+
+  virtual bool OnClearCurrent() = 0;
+
+  virtual bool OnMakeResourceCurrent() = 0;
+
+  virtual bool OnPresent() = 0;
+
+  virtual uint32_t OnGetFBO() = 0;
+
+  virtual void* OnProcResolver(const char* name) = 0;
+
+  virtual bool IsSupportedExtension(const char* name) = 0;
+
+  FlutterRendererConfig GetRendererConfig() override;
+
+  ExternalTextureExtensionType GetExternalTextureExtensionType();
+};
+
+}  // namespace flutter
+
+#endif  // EMBEDDER_TIZEN_RENDERER_GL_H_
diff --git a/flutter/shell/platform/tizen/tizen_renderer_nui_gl.cc b/flutter/shell/platform/tizen/tizen_renderer_nui_gl.cc
new file mode 100644
index 0000000..5f33275
--- /dev/null
+++ b/flutter/shell/platform/tizen/tizen_renderer_nui_gl.cc
@@ -0,0 +1,21 @@
+// Copyright 2025 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/tizen/tizen_renderer_nui_gl.h"
+
+namespace flutter {
+
+TizenRendererNuiGL::TizenRendererNuiGL(TizenViewNui* view_nui,
+                                       bool enable_impeller)
+    : TizenRendererEgl(view_nui, enable_impeller), view_(view_nui) {}
+
+TizenRendererNuiGL::~TizenRendererNuiGL() {}
+
+bool TizenRendererNuiGL::OnPresent() {
+  bool result = TizenRendererEgl::OnPresent();
+  view_->RequestRendering();
+  return result;
+}
+
+}  // namespace flutter
diff --git a/flutter/shell/platform/tizen/tizen_renderer_nui_gl.h b/flutter/shell/platform/tizen/tizen_renderer_nui_gl.h
new file mode 100644
index 0000000..abc5ba4
--- /dev/null
+++ b/flutter/shell/platform/tizen/tizen_renderer_nui_gl.h
@@ -0,0 +1,30 @@
+// Copyright 2025 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef EMBEDDER_TIZEN_RENDERER_NUI_H_
+#define EMBEDDER_TIZEN_RENDERER_NUI_H_
+
+#include <cstdint>
+#include <memory>
+#include "flutter/shell/platform/tizen/tizen_renderer_egl.h"
+#include "flutter/shell/platform/tizen/tizen_renderer_gl.h"
+#include "flutter/shell/platform/tizen/tizen_view_nui.h"
+
+namespace flutter {
+
+class TizenRendererNuiGL : public TizenRendererEgl {
+ public:
+  explicit TizenRendererNuiGL(TizenViewNui* view_nui, bool enable_impeller);
+
+  virtual ~TizenRendererNuiGL();
+
+  bool OnPresent() override;
+
+ private:
+  TizenViewNui* view_;
+};
+
+}  // namespace flutter
+
+#endif  // EMBEDDER_TIZEN_RENDERER_NUI_H_