From fb1ade89cc3b73c63c4295d3b2b6eddfd8972a6b Mon Sep 17 00:00:00 2001
From: dan sinclair <dj2@everburning.com>
Date: Tue, 11 Dec 2018 15:11:15 -0500
Subject: Merge scripts and executors. (#170)

This CL merges the vk and amber Script classes along with the vk and
amber Executor classes.
---
 Android.mk                       |   6 +-
 src/CMakeLists.txt               |  11 +-
 src/amber.cc                     |  11 +-
 src/amberscript/executor.cc      |  36 --
 src/amberscript/executor.h       |  37 --
 src/amberscript/parser.cc        |   3 +-
 src/amberscript/parser.h         |   7 +-
 src/amberscript/parser_test.cc   |  59 +--
 src/amberscript/pipeline.cc      | 144 ------
 src/amberscript/pipeline.h       |  85 ----
 src/amberscript/pipeline_test.cc | 333 -------------
 src/amberscript/script.cc        |  30 --
 src/amberscript/script.h         |  85 ----
 src/amberscript/script_test.cc   | 248 ----------
 src/engine.h                     |   6 +-
 src/executor.cc                  | 134 ++++++
 src/executor.h                   |  10 +-
 src/executor_test.cc             | 992 +++++++++++++++++++++++++++++++++++++++
 src/pipeline.cc                  | 142 ++++++
 src/pipeline.h                   |  83 ++++
 src/pipeline_test.cc             | 331 +++++++++++++
 src/script.cc                    |   2 +-
 src/script.h                     |  36 +-
 src/script_test.cc               | 220 ++++++++-
 src/vkscript/executor.cc         | 162 -------
 src/vkscript/executor.h          |  39 --
 src/vkscript/executor_test.cc    | 992 ---------------------------------------
 src/vkscript/parser.cc           |   2 +-
 src/vkscript/parser.h            |   8 +-
 src/vkscript/parser_test.cc      |   2 +-
 src/vkscript/script.cc           |  34 --
 src/vkscript/script.h            |  42 --
 32 files changed, 1969 insertions(+), 2363 deletions(-)
 delete mode 100644 src/amberscript/executor.cc
 delete mode 100644 src/amberscript/executor.h
 delete mode 100644 src/amberscript/pipeline.cc
 delete mode 100644 src/amberscript/pipeline.h
 delete mode 100644 src/amberscript/pipeline_test.cc
 delete mode 100644 src/amberscript/script.cc
 delete mode 100644 src/amberscript/script.h
 delete mode 100644 src/amberscript/script_test.cc
 create mode 100644 src/executor_test.cc
 create mode 100644 src/pipeline.cc
 create mode 100644 src/pipeline.h
 create mode 100644 src/pipeline_test.cc
 delete mode 100644 src/vkscript/executor.cc
 delete mode 100644 src/vkscript/executor.h
 delete mode 100644 src/vkscript/executor_test.cc
 delete mode 100644 src/vkscript/script.cc
 delete mode 100644 src/vkscript/script.h

diff --git a/Android.mk b/Android.mk
index 3c4dfb1..8b85179 100644
--- a/Android.mk
+++ b/Android.mk
@@ -5,10 +5,7 @@ LOCAL_MODULE:=amber
 LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti
 LOCAL_SRC_FILES:= \
     src/amber.cc \
-    src/amberscript/executor.cc \
     src/amberscript/parser.cc \
-    src/amberscript/pipeline.cc \
-    src/amberscript/script.cc \
     src/buffer.cc \
     src/command.cc \
     src/command_data.cc \
@@ -17,6 +14,7 @@ LOCAL_SRC_FILES:= \
     src/executor.cc \
     src/format.cc \
     src/parser.cc \
+    src/pipeline.cc \
     src/pipeline_data.cc \
     src/recipe.cc \
     src/result.cc \
@@ -28,10 +26,8 @@ LOCAL_SRC_FILES:= \
     src/verifier.cc \
     src/vkscript/command_parser.cc \
     src/vkscript/datum_type_parser.cc \
-    src/vkscript/executor.cc \
     src/vkscript/format_parser.cc \
     src/vkscript/parser.cc \
-    src/vkscript/script.cc \
     src/vkscript/section_parser.cc
 LOCAL_STATIC_LIBRARIES:=glslang SPIRV-Tools shaderc
 LOCAL_C_INCLUDES:=$(LOCAL_PATH)/include
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 230c8db..67184d9 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -14,10 +14,7 @@
 
 set(AMBER_SOURCES
     amber.cc
-    amberscript/executor.cc
     amberscript/parser.cc
-    amberscript/pipeline.cc
-    amberscript/script.cc
     buffer.cc
     command.cc
     command_data.cc
@@ -26,6 +23,7 @@ set(AMBER_SOURCES
     executor.cc
     format.cc
     parser.cc
+    pipeline.cc
     pipeline_data.cc
     recipe.cc
     result.cc
@@ -38,10 +36,8 @@ set(AMBER_SOURCES
     verifier.cc
     vkscript/command_parser.cc
     vkscript/datum_type_parser.cc
-    vkscript/executor.cc
     vkscript/format_parser.cc
     vkscript/parser.cc
-    vkscript/script.cc
     vkscript/section_parser.cc
 )
 
@@ -78,10 +74,10 @@ endif()
 if (${AMBER_ENABLE_TESTS})
   set(TEST_SRCS
     amberscript/parser_test.cc
-    amberscript/pipeline_test.cc
-    amberscript/script_test.cc
     buffer_test.cc
     command_data_test.cc
+    executor_test.cc
+    pipeline_test.cc
     result_test.cc
     script_test.cc
     shader_compiler_test.cc
@@ -89,7 +85,6 @@ if (${AMBER_ENABLE_TESTS})
     verifier_test.cc
     vkscript/command_parser_test.cc
     vkscript/datum_type_parser_test.cc
-    vkscript/executor_test.cc
     vkscript/format_parser_test.cc
     vkscript/parser_test.cc
     vkscript/section_parser_test.cc
diff --git a/src/amber.cc b/src/amber.cc
index 5cb3309..65ef22d 100644
--- a/src/amber.cc
+++ b/src/amber.cc
@@ -17,13 +17,11 @@
 #include <memory>
 #include <string>
 
-#include "src/amberscript/executor.h"
 #include "src/amberscript/parser.h"
 #include "src/engine.h"
 #include "src/executor.h"
 #include "src/make_unique.h"
 #include "src/parser.h"
-#include "src/vkscript/executor.h"
 #include "src/vkscript/parser.h"
 
 namespace amber {
@@ -81,13 +79,8 @@ amber::Result Amber::ExecuteWithShaderData(const amber::Recipe* recipe,
   if (!r.IsSuccess())
     return r;
 
-  std::unique_ptr<Executor> executor;
-  if (script->IsVkScript())
-    executor = MakeUnique<vkscript::Executor>();
-  else
-    executor = MakeUnique<amberscript::Executor>();
-
-  r = executor->Execute(engine.get(), script, shader_data);
+  Executor executor;
+  r = executor.Execute(engine.get(), script, shader_data);
   if (!r.IsSuccess())
     return r;
 
diff --git a/src/amberscript/executor.cc b/src/amberscript/executor.cc
deleted file mode 100644
index 1c9954b..0000000
--- a/src/amberscript/executor.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/amberscript/executor.h"
-
-namespace amber {
-namespace amberscript {
-
-Executor::Executor() : amber::Executor() {}
-
-Executor::~Executor() = default;
-
-Result Executor::Execute(Engine*,
-                         const amber::Script* src_script,
-                         const ShaderMap&) {
-  if (!src_script->IsAmberScript())
-    return Result("AmberScript executor called with non-amber script source");
-
-  // const amberscript::Script* script = ToAmberScript(src_script);
-
-  return {};
-}
-
-}  // namespace amberscript
-}  // namespace amber
diff --git a/src/amberscript/executor.h b/src/amberscript/executor.h
deleted file mode 100644
index 71b6098..0000000
--- a/src/amberscript/executor.h
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_AMBERSCRIPT_EXECUTOR_H_
-#define SRC_AMBERSCRIPT_EXECUTOR_H_
-
-#include "amber/result.h"
-#include "src/engine.h"
-#include "src/executor.h"
-#include "src/script.h"
-
-namespace amber {
-namespace amberscript {
-
-class Executor : public amber::Executor {
- public:
-  Executor();
-  ~Executor() override;
-
-  Result Execute(Engine*, const amber::Script*, const ShaderMap&) override;
-};
-
-}  // namespace amberscript
-}  // namespace amber
-
-#endif  // SRC_AMBERSCRIPT_EXECUTOR_H_
diff --git a/src/amberscript/parser.cc b/src/amberscript/parser.cc
index d45c52a..2e004cb 100644
--- a/src/amberscript/parser.cc
+++ b/src/amberscript/parser.cc
@@ -27,8 +27,7 @@
 namespace amber {
 namespace amberscript {
 
-Parser::Parser()
-    : amber::Parser(), script_(MakeUnique<amberscript::Script>()) {}
+Parser::Parser() : amber::Parser(), script_(MakeUnique<Script>()) {}
 
 Parser::~Parser() = default;
 
diff --git a/src/amberscript/parser.h b/src/amberscript/parser.h
index 7e4b764..7f0fc05 100644
--- a/src/amberscript/parser.h
+++ b/src/amberscript/parser.h
@@ -20,7 +20,6 @@
 #include <utility>
 
 #include "amber/result.h"
-#include "src/amberscript/script.h"
 #include "src/parser.h"
 #include "src/script.h"
 
@@ -37,9 +36,7 @@ class Parser : public amber::Parser {
 
   // amber::Parser
   Result Parse(const std::string& data) override;
-  std::unique_ptr<amber::Script> GetScript() override {
-    return std::move(script_);
-  }
+  std::unique_ptr<Script> GetScript() override { return std::move(script_); }
 
  private:
   std::string make_error(const std::string& err);
@@ -63,7 +60,7 @@ class Parser : public amber::Parser {
   Result ParsePipelineEntryPoint(Pipeline*);
   Result ParsePipelineShaderOptimizations(Pipeline*);
 
-  std::unique_ptr<amberscript::Script> script_;
+  std::unique_ptr<Script> script_;
   std::unique_ptr<Tokenizer> tokenizer_;
 };
 
diff --git a/src/amberscript/parser_test.cc b/src/amberscript/parser_test.cc
index fd57a5d..03f3fe8 100644
--- a/src/amberscript/parser_test.cc
+++ b/src/amberscript/parser_test.cc
@@ -60,7 +60,7 @@ TEST_F(AmberScriptParserTest, EmptyInput) {
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
   auto script = parser.GetScript();
-  ASSERT_TRUE(script->IsAmberScript());
+  ASSERT_TRUE(script != nullptr);
 }
 
 TEST_F(AmberScriptParserTest, InvalidStartToken) {
@@ -90,8 +90,7 @@ TEST_F(AmberScriptParserTest, ShaderPassThrough) {
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& shaders = script->GetShaders();
   ASSERT_EQ(1U, shaders.size());
 
@@ -197,8 +196,7 @@ SHADER geometry shader_name GLSL
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& shaders = script->GetShaders();
   ASSERT_EQ(1U, shaders.size());
 
@@ -312,8 +310,7 @@ void main() {
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& shaders = script->GetShaders();
   ASSERT_EQ(1U, shaders.size());
 
@@ -354,8 +351,7 @@ TEST_P(AmberScriptParserShaderFormatTest, ShaderFormats) {
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& shaders = script->GetShaders();
   ASSERT_EQ(1U, shaders.size());
 
@@ -407,8 +403,7 @@ END
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   EXPECT_EQ(2U, script->GetShaders().size());
 
   const auto& pipelines = script->GetPipelines();
@@ -672,8 +667,7 @@ END
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& pipelines = script->GetPipelines();
   ASSERT_EQ(1U, pipelines.size());
 
@@ -819,8 +813,7 @@ END
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& pipelines = script->GetPipelines();
   ASSERT_EQ(1U, pipelines.size());
 
@@ -949,8 +942,7 @@ END)";
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(1U, buffers.size());
 
@@ -980,8 +972,7 @@ TEST_F(AmberScriptParserTest, BufferFill) {
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(1U, buffers.size());
 
@@ -1010,8 +1001,7 @@ TEST_F(AmberScriptParserTest, BufferFillFloat) {
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(1U, buffers.size());
 
@@ -1041,8 +1031,7 @@ TEST_F(AmberScriptParserTest, BufferSeries) {
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(1U, buffers.size());
 
@@ -1073,8 +1062,7 @@ TEST_F(AmberScriptParserTest, BufferSeriesFloat) {
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(1U, buffers.size());
 
@@ -1103,8 +1091,7 @@ TEST_F(AmberScriptParserTest, BufferFramebuffer) {
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(1U, buffers.size());
 
@@ -1131,8 +1118,7 @@ END)";
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(2U, buffers.size());
 
@@ -1179,8 +1165,7 @@ BUFFER index my_index_buffer DATA_TYPE vec2<int32> SIZE 5 FILL 2)";
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(1U, buffers.size());
 
@@ -1216,8 +1201,7 @@ END
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(1U, buffers.size());
 
@@ -1253,8 +1237,7 @@ END
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(1U, buffers.size());
 
@@ -1633,8 +1616,7 @@ TEST_P(AmberScriptParserBufferTypeTest, BufferTypes) {
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(1U, buffers.size());
 
@@ -1665,8 +1647,7 @@ TEST_P(AmberScriptParserBufferDataTypeTest, BufferTypes) {
   Result r = parser.Parse(in);
   ASSERT_TRUE(r.IsSuccess()) << test_data.name << " :" << r.Error();
 
-  auto parent_script = parser.GetScript();
-  auto script = ToAmberScript(parent_script.get());
+  auto script = parser.GetScript();
   const auto& buffers = script->GetBuffers();
   ASSERT_EQ(1U, buffers.size());
 
diff --git a/src/amberscript/pipeline.cc b/src/amberscript/pipeline.cc
deleted file mode 100644
index 94f498b..0000000
--- a/src/amberscript/pipeline.cc
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/amberscript/pipeline.h"
-
-#include <algorithm>
-#include <set>
-
-namespace amber {
-namespace amberscript {
-
-Pipeline::ShaderInfo::ShaderInfo(const Shader* shader)
-    : shader_(shader), entry_point_("main") {}
-
-Pipeline::ShaderInfo::ShaderInfo(const ShaderInfo&) = default;
-
-Pipeline::ShaderInfo::~ShaderInfo() = default;
-
-Pipeline::Pipeline(PipelineType type) : pipeline_type_(type) {}
-
-Pipeline::~Pipeline() = default;
-
-Result Pipeline::AddShader(const Shader* shader) {
-  if (!shader)
-    return Result("shader can not be null when attached to pipeline");
-
-  if (pipeline_type_ == PipelineType::kCompute &&
-      shader->GetType() != ShaderType::kCompute) {
-    return Result("only compute shaders allowed in a compute pipeline");
-  }
-  if (pipeline_type_ == PipelineType::kGraphics &&
-      shader->GetType() == ShaderType::kCompute) {
-    return Result("can not add a compute shader to a graphics pipeline");
-  }
-
-  for (const auto& info : shaders_) {
-    const auto* is = info.GetShader();
-    if (is == shader)
-      return Result("can not add duplicate shader to pipeline");
-    if (is->GetType() == shader->GetType())
-      return Result("can not add duplicate shader type to pipeline");
-  }
-
-  shaders_.emplace_back(shader);
-  return {};
-}
-
-Result Pipeline::SetShaderOptimizations(const Shader* shader,
-                                        const std::vector<std::string>& opts) {
-  if (!shader)
-    return Result("invalid shader specified for optimizations");
-
-  std::set<std::string> seen;
-  for (const auto& opt : opts) {
-    if (seen.count(opt) != 0)
-      return Result("duplicate optimization flag (" + opt + ") set on shader");
-
-    seen.insert(opt);
-  }
-
-  for (auto& info : shaders_) {
-    const auto* is = info.GetShader();
-    if (is == shader) {
-      info.SetShaderOptimizations(opts);
-      return {};
-    }
-  }
-
-  return Result("unknown shader specified for optimizations: " +
-                shader->GetName());
-}
-
-Result Pipeline::SetShaderEntryPoint(const Shader* shader,
-                                     const std::string& name) {
-  if (!shader)
-    return Result("invalid shader specified for entry point");
-  if (name.empty())
-    return Result("entry point should not be blank");
-
-  for (auto& info : shaders_) {
-    if (info.GetShader() == shader) {
-      if (info.GetEntryPoint() != "main")
-        return Result("multiple entry points given for the same shader");
-
-      info.SetEntryPoint(name);
-      return {};
-    }
-  }
-
-  return Result("unknown shader specified for entry point: " +
-                shader->GetName());
-}
-
-Result Pipeline::Validate() const {
-  if (pipeline_type_ == PipelineType::kGraphics)
-    return ValidateGraphics();
-  return ValidateCompute();
-}
-
-Result Pipeline::ValidateGraphics() const {
-  if (shaders_.empty())
-    return Result("graphics pipeline requires vertex and fragment shaders");
-
-  bool found_vertex = false;
-  bool found_fragment = false;
-  for (const auto& info : shaders_) {
-    const auto* is = info.GetShader();
-    if (is->GetType() == ShaderType::kVertex)
-      found_vertex = true;
-    if (is->GetType() == ShaderType::kFragment)
-      found_fragment = true;
-    if (found_vertex && found_fragment)
-      break;
-  }
-
-  if (!found_vertex && !found_fragment)
-    return Result("graphics pipeline requires vertex and fragment shaders");
-  if (!found_vertex)
-    return Result("graphics pipeline requires a vertex shader");
-  if (!found_fragment)
-    return Result("graphics pipeline requires a fragment shader");
-  return {};
-}
-
-Result Pipeline::ValidateCompute() const {
-  if (shaders_.empty())
-    return Result("compute pipeline requires a compute shader");
-
-  return {};
-}
-
-}  // namespace amberscript
-}  // namespace amber
diff --git a/src/amberscript/pipeline.h b/src/amberscript/pipeline.h
deleted file mode 100644
index ba7bdb1..0000000
--- a/src/amberscript/pipeline.h
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_AMBERSCRIPT_PIPELINE_H_
-#define SRC_AMBERSCRIPT_PIPELINE_H_
-
-#include <string>
-#include <vector>
-
-#include "amber/result.h"
-#include "src/shader.h"
-
-namespace amber {
-namespace amberscript {
-
-enum class PipelineType { kCompute = 0, kGraphics };
-
-class Pipeline {
- public:
-  class ShaderInfo {
-   public:
-    explicit ShaderInfo(const Shader*);
-    ShaderInfo(const ShaderInfo&);
-    ~ShaderInfo();
-
-    void SetShaderOptimizations(const std::vector<std::string>& opts) {
-      shader_optimizations_ = opts;
-    }
-    const std::vector<std::string>& GetShaderOptimizations() const {
-      return shader_optimizations_;
-    }
-
-    const Shader* GetShader() const { return shader_; }
-
-    void SetEntryPoint(const std::string& ep) { entry_point_ = ep; }
-    std::string GetEntryPoint() const { return entry_point_; }
-
-   private:
-    const Shader* shader_ = nullptr;
-    std::vector<std::string> shader_optimizations_;
-    std::string entry_point_;
-  };
-
-  explicit Pipeline(PipelineType type);
-  ~Pipeline();
-
-  PipelineType GetType() const { return pipeline_type_; }
-
-  void SetName(const std::string& name) { name_ = name; }
-  const std::string& GetName() const { return name_; }
-
-  Result AddShader(const Shader*);
-  const std::vector<ShaderInfo>& GetShaders() const { return shaders_; }
-
-  Result SetShaderEntryPoint(const Shader* shader, const std::string& name);
-  Result SetShaderOptimizations(const Shader* shader,
-                                const std::vector<std::string>& opts);
-
-  // Validates that the pipeline has been created correctly.
-  Result Validate() const;
-
- private:
-  Result ValidateGraphics() const;
-  Result ValidateCompute() const;
-
-  PipelineType pipeline_type_ = PipelineType::kCompute;
-  std::string name_;
-  std::vector<ShaderInfo> shaders_;
-};
-
-}  // namespace amberscript
-}  // namespace amber
-
-#endif  // SRC_AMBERSCRIPT_PIPELINE_H_
diff --git a/src/amberscript/pipeline_test.cc b/src/amberscript/pipeline_test.cc
deleted file mode 100644
index b0866f1..0000000
--- a/src/amberscript/pipeline_test.cc
+++ /dev/null
@@ -1,333 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/amberscript/pipeline.h"
-#include "gtest/gtest.h"
-
-namespace amber {
-namespace amberscript {
-namespace {
-
-struct ShaderTypeData {
-  ShaderType type;
-};
-
-}  // namespace
-
-using AmberScriptPipelineTest = testing::Test;
-
-TEST_F(AmberScriptPipelineTest, AddShader) {
-  Shader v(ShaderType::kVertex);
-  Shader f(ShaderType::kFragment);
-
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.AddShader(&v);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.AddShader(&f);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  const auto& shaders = p.GetShaders();
-  EXPECT_EQ(2U, shaders.size());
-
-  EXPECT_EQ(&v, shaders[0].GetShader());
-  EXPECT_EQ(&f, shaders[1].GetShader());
-}
-
-TEST_F(AmberScriptPipelineTest, MissingShader) {
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.AddShader(nullptr);
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("shader can not be null when attached to pipeline", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, DuplicateShaders) {
-  Shader v(ShaderType::kVertex);
-  Shader f(ShaderType::kFragment);
-
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.AddShader(&v);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.AddShader(&f);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.AddShader(&v);
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("can not add duplicate shader to pipeline", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, DuplicateShaderType) {
-  Shader v(ShaderType::kVertex);
-  Shader f(ShaderType::kVertex);
-
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.AddShader(&v);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.AddShader(&f);
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("can not add duplicate shader type to pipeline", r.Error());
-}
-
-using AmberScriptPipelineComputePipelineTest =
-    testing::TestWithParam<ShaderTypeData>;
-TEST_P(AmberScriptPipelineComputePipelineTest,
-       SettingGraphicsShaderToComputePipeline) {
-  const auto test_data = GetParam();
-
-  Shader s(test_data.type);
-
-  Pipeline p(PipelineType::kCompute);
-  Result r = p.AddShader(&s);
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("only compute shaders allowed in a compute pipeline", r.Error());
-}
-INSTANTIATE_TEST_CASE_P(
-    AmberScriptPipelineComputePipelineTests,
-    AmberScriptPipelineComputePipelineTest,
-    testing::Values(
-        ShaderTypeData{ShaderType::kVertex},
-        ShaderTypeData{ShaderType::kFragment},
-        ShaderTypeData{ShaderType::kGeometry},
-        ShaderTypeData{ShaderType::kTessellationEvaluation},
-        ShaderTypeData{
-            ShaderType::kTessellationControl}), );  // NOLINT(whitespace/parens)
-
-TEST_F(AmberScriptPipelineTest, SettingComputeShaderToGraphicsPipeline) {
-  Shader c(ShaderType::kCompute);
-
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.AddShader(&c);
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("can not add a compute shader to a graphics pipeline", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, SetShaderOptimizations) {
-  Shader v(ShaderType::kVertex);
-  Shader f(ShaderType::kFragment);
-
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.AddShader(&v);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.AddShader(&f);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  std::vector<std::string> first = {"First", "Second"};
-  std::vector<std::string> second = {"Third", "Forth"};
-
-  r = p.SetShaderOptimizations(&f, first);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.SetShaderOptimizations(&v, second);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  const auto& shaders = p.GetShaders();
-  EXPECT_EQ(2U, shaders.size());
-  EXPECT_EQ(second, shaders[0].GetShaderOptimizations());
-  EXPECT_EQ(first, shaders[1].GetShaderOptimizations());
-}
-
-TEST_F(AmberScriptPipelineTest, DuplicateShaderOptimizations) {
-  Shader v(ShaderType::kVertex);
-
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.AddShader(&v);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  std::vector<std::string> data = {"One", "One"};
-  r = p.SetShaderOptimizations(&v, data);
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("duplicate optimization flag (One) set on shader", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, SetOptimizationForMissingShader) {
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.SetShaderOptimizations(nullptr, {"One", "Two"});
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("invalid shader specified for optimizations", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, SetOptimizationForInvalidShader) {
-  Shader v(ShaderType::kVertex);
-  v.SetName("my_shader");
-
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.SetShaderOptimizations(&v, {"One", "Two"});
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("unknown shader specified for optimizations: my_shader", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest,
-       GraphicsPipelineRequiresVertexAndFragmentShader) {
-  Shader v(ShaderType::kVertex);
-  Shader f(ShaderType::kFragment);
-  Shader g(ShaderType::kGeometry);
-
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.AddShader(&v);
-  EXPECT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.AddShader(&g);
-  EXPECT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.AddShader(&f);
-  EXPECT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.Validate();
-  EXPECT_TRUE(r.IsSuccess()) << r.Error();
-}
-
-TEST_F(AmberScriptPipelineTest, GraphicsPipelineMissingFragmentShader) {
-  Shader v(ShaderType::kVertex);
-  Shader g(ShaderType::kGeometry);
-
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.AddShader(&v);
-  EXPECT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.AddShader(&g);
-  EXPECT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.Validate();
-  EXPECT_FALSE(r.IsSuccess()) << r.Error();
-  EXPECT_EQ("graphics pipeline requires a fragment shader", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, GraphicsPipelineMissingVertexShader) {
-  Shader f(ShaderType::kFragment);
-  Shader g(ShaderType::kGeometry);
-
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.AddShader(&g);
-  EXPECT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.AddShader(&f);
-  EXPECT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.Validate();
-  EXPECT_FALSE(r.IsSuccess()) << r.Error();
-  EXPECT_EQ("graphics pipeline requires a vertex shader", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest,
-       GraphicsPipelineMissingVertexAndFragmentShader) {
-  Shader g(ShaderType::kGeometry);
-
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.AddShader(&g);
-  EXPECT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.Validate();
-  EXPECT_FALSE(r.IsSuccess()) << r.Error();
-  EXPECT_EQ("graphics pipeline requires vertex and fragment shaders",
-            r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, GraphicsPipelineWihoutShaders) {
-  Pipeline p(PipelineType::kGraphics);
-  Result r = p.Validate();
-  EXPECT_FALSE(r.IsSuccess()) << r.Error();
-  EXPECT_EQ("graphics pipeline requires vertex and fragment shaders",
-            r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, ComputePipelineRequiresComputeShader) {
-  Shader c(ShaderType::kCompute);
-
-  Pipeline p(PipelineType::kCompute);
-  Result r = p.AddShader(&c);
-  EXPECT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.Validate();
-  EXPECT_TRUE(r.IsSuccess()) << r.Error();
-}
-
-TEST_F(AmberScriptPipelineTest, ComputePipelineWithoutShader) {
-  Pipeline p(PipelineType::kCompute);
-  Result r = p.Validate();
-  EXPECT_FALSE(r.IsSuccess()) << r.Error();
-  EXPECT_EQ("compute pipeline requires a compute shader", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, SetEntryPointForMissingShader) {
-  Shader c(ShaderType::kCompute);
-  c.SetName("my_shader");
-
-  Pipeline p(PipelineType::kCompute);
-  Result r = p.SetShaderEntryPoint(&c, "test");
-  EXPECT_FALSE(r.IsSuccess());
-  EXPECT_EQ("unknown shader specified for entry point: my_shader", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, SetEntryPointForNullShader) {
-  Pipeline p(PipelineType::kCompute);
-  Result r = p.SetShaderEntryPoint(nullptr, "test");
-  EXPECT_FALSE(r.IsSuccess());
-  EXPECT_EQ("invalid shader specified for entry point", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, SetBlankEntryPoint) {
-  Shader c(ShaderType::kCompute);
-  Pipeline p(PipelineType::kCompute);
-  Result r = p.AddShader(&c);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.SetShaderEntryPoint(&c, "");
-  EXPECT_FALSE(r.IsSuccess());
-  EXPECT_EQ("entry point should not be blank", r.Error());
-}
-
-TEST_F(AmberScriptPipelineTest, ShaderDefaultEntryPoint) {
-  Shader c(ShaderType::kCompute);
-  Pipeline p(PipelineType::kCompute);
-  Result r = p.AddShader(&c);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  const auto& shaders = p.GetShaders();
-  ASSERT_EQ(1U, shaders.size());
-  EXPECT_EQ("main", shaders[0].GetEntryPoint());
-}
-
-TEST_F(AmberScriptPipelineTest, SetShaderEntryPoint) {
-  Shader c(ShaderType::kCompute);
-  Pipeline p(PipelineType::kCompute);
-  Result r = p.AddShader(&c);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.SetShaderEntryPoint(&c, "my_main");
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  const auto& shaders = p.GetShaders();
-  ASSERT_EQ(1U, shaders.size());
-  EXPECT_EQ("my_main", shaders[0].GetEntryPoint());
-}
-
-TEST_F(AmberScriptPipelineTest, SetEntryPointMulitpleTimes) {
-  Shader c(ShaderType::kCompute);
-  Pipeline p(PipelineType::kCompute);
-  Result r = p.AddShader(&c);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.SetShaderEntryPoint(&c, "my_main");
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  r = p.SetShaderEntryPoint(&c, "another_main");
-  EXPECT_FALSE(r.IsSuccess());
-  EXPECT_EQ("multiple entry points given for the same shader", r.Error());
-}
-
-}  // namespace amberscript
-}  // namespace amber
diff --git a/src/amberscript/script.cc b/src/amberscript/script.cc
deleted file mode 100644
index 17bfedc..0000000
--- a/src/amberscript/script.cc
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/amberscript/script.h"
-
-namespace amber {
-namespace amberscript {
-
-Script::Script() : amber::Script(ScriptType::kAmberScript) {}
-
-Script::~Script() = default;
-
-}  // namespace amberscript
-
-const amberscript::Script* ToAmberScript(const amber::Script* s) {
-  return static_cast<const amberscript::Script*>(s);
-}
-
-}  // namespace amber
diff --git a/src/amberscript/script.h b/src/amberscript/script.h
deleted file mode 100644
index 81d0258..0000000
--- a/src/amberscript/script.h
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_AMBERSCRIPT_SCRIPT_H_
-#define SRC_AMBERSCRIPT_SCRIPT_H_
-
-#include <map>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "src/amberscript/pipeline.h"
-#include "src/buffer.h"
-#include "src/script.h"
-
-namespace amber {
-namespace amberscript {
-
-class Script : public amber::Script {
- public:
-  Script();
-  ~Script() override;
-
-  Result AddPipeline(std::unique_ptr<Pipeline> pipeline) {
-    if (name_to_pipeline_.count(pipeline->GetName()) > 0)
-      return Result("duplicate pipeline name provided");
-
-    pipelines_.push_back(std::move(pipeline));
-    name_to_pipeline_[pipelines_.back()->GetName()] = pipelines_.back().get();
-    return {};
-  }
-
-  Pipeline* GetPipeline(const std::string& name) const {
-    auto it = name_to_pipeline_.find(name);
-    return it == name_to_pipeline_.end() ? nullptr : it->second;
-  }
-
-  const std::vector<std::unique_ptr<Pipeline>>& GetPipelines() const {
-    return pipelines_;
-  }
-
-  Result AddBuffer(std::unique_ptr<Buffer> buffer) {
-    if (name_to_buffer_.count(buffer->GetName()) > 0)
-      return Result("duplicate buffer name provided");
-
-    buffers_.push_back(std::move(buffer));
-    name_to_buffer_[buffers_.back()->GetName()] = buffers_.back().get();
-    return {};
-  }
-
-  Buffer* GetBuffer(const std::string& name) const {
-    auto it = name_to_buffer_.find(name);
-    return it == name_to_buffer_.end() ? nullptr : it->second;
-  }
-
-  const std::vector<std::unique_ptr<Buffer>>& GetBuffers() const {
-    return buffers_;
-  }
-
- private:
-  std::map<std::string, Pipeline*> name_to_pipeline_;
-  std::map<std::string, Buffer*> name_to_buffer_;
-  std::vector<std::unique_ptr<Pipeline>> pipelines_;
-  std::vector<std::unique_ptr<Buffer>> buffers_;
-};
-
-}  // namespace amberscript
-
-const amberscript::Script* ToAmberScript(const amber::Script* s);
-
-}  // namespace amber
-
-#endif  // SRC_AMBERSCRIPT_SCRIPT_H_
diff --git a/src/amberscript/script_test.cc b/src/amberscript/script_test.cc
deleted file mode 100644
index 2a2bd5e..0000000
--- a/src/amberscript/script_test.cc
+++ /dev/null
@@ -1,248 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <utility>
-
-#include "gtest/gtest.h"
-#include "src/amberscript/pipeline.h"
-#include "src/amberscript/script.h"
-#include "src/buffer.h"
-#include "src/make_unique.h"
-#include "src/shader.h"
-
-namespace amber {
-namespace amberscript {
-
-using ScriptTest = testing::Test;
-
-TEST_F(ScriptTest, AddShader) {
-  auto shader = MakeUnique<Shader>(ShaderType::kVertex);
-  shader->SetName("My Shader");
-
-  Script s;
-  Result r = s.AddShader(std::move(shader));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-}
-
-TEST_F(ScriptTest, AddDuplicateShader) {
-  auto shader1 = MakeUnique<Shader>(ShaderType::kVertex);
-  shader1->SetName("My Shader");
-
-  Script s;
-  Result r = s.AddShader(std::move(shader1));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  auto shader2 = MakeUnique<Shader>(ShaderType::kFragment);
-  shader2->SetName("My Shader");
-
-  r = s.AddShader(std::move(shader2));
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("duplicate shader name provided", r.Error());
-}
-
-TEST_F(ScriptTest, GetShader) {
-  auto shader = MakeUnique<Shader>(ShaderType::kVertex);
-  shader->SetName("My Shader");
-
-  auto* ptr = shader.get();
-
-  Script s;
-  Result r = s.AddShader(std::move(shader));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  EXPECT_EQ(ptr, s.GetShader("My Shader"));
-}
-
-TEST_F(ScriptTest, GetMissingShader) {
-  Script s;
-  EXPECT_TRUE(s.GetShader("My Shader") == nullptr);
-}
-
-TEST_F(ScriptTest, GetShadersEmpty) {
-  Script s;
-  const auto& shaders = s.GetShaders();
-  EXPECT_TRUE(shaders.empty());
-}
-
-TEST_F(ScriptTest, GetShaders) {
-  auto shader1 = MakeUnique<Shader>(ShaderType::kVertex);
-  shader1->SetName("My Shader");
-
-  const auto* ptr1 = shader1.get();
-
-  Script s;
-  Result r = s.AddShader(std::move(shader1));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  auto shader2 = MakeUnique<Shader>(ShaderType::kFragment);
-  shader2->SetName("My Fragment");
-
-  const auto* ptr2 = shader2.get();
-
-  r = s.AddShader(std::move(shader2));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  const auto& shaders = s.GetShaders();
-  ASSERT_EQ(2U, shaders.size());
-  EXPECT_EQ(ptr1, shaders[0].get());
-  EXPECT_EQ(ptr2, shaders[1].get());
-}
-
-TEST_F(ScriptTest, AddPipeline) {
-  auto pipeline = MakeUnique<Pipeline>(PipelineType::kCompute);
-  pipeline->SetName("my_pipeline");
-
-  Script s;
-  Result r = s.AddPipeline(std::move(pipeline));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-}
-
-TEST_F(ScriptTest, AddDuplicatePipeline) {
-  auto pipeline1 = MakeUnique<Pipeline>(PipelineType::kCompute);
-  pipeline1->SetName("my_pipeline");
-
-  Script s;
-  Result r = s.AddPipeline(std::move(pipeline1));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  auto pipeline2 = MakeUnique<Pipeline>(PipelineType::kGraphics);
-  pipeline2->SetName("my_pipeline");
-  r = s.AddPipeline(std::move(pipeline2));
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("duplicate pipeline name provided", r.Error());
-}
-
-TEST_F(ScriptTest, GetPipeline) {
-  auto pipeline = MakeUnique<Pipeline>(PipelineType::kCompute);
-  pipeline->SetName("my_pipeline");
-
-  const auto* ptr = pipeline.get();
-
-  Script s;
-  Result r = s.AddPipeline(std::move(pipeline));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  EXPECT_EQ(ptr, s.GetPipeline("my_pipeline"));
-}
-
-TEST_F(ScriptTest, GetMissingPipeline) {
-  Script s;
-  EXPECT_TRUE(s.GetPipeline("my_pipeline") == nullptr);
-}
-
-TEST_F(ScriptTest, GetPipelinesEmpty) {
-  Script s;
-  const auto& pipelines = s.GetPipelines();
-  EXPECT_TRUE(pipelines.empty());
-}
-
-TEST_F(ScriptTest, GetPipelines) {
-  auto pipeline1 = MakeUnique<Pipeline>(PipelineType::kCompute);
-  pipeline1->SetName("my_pipeline1");
-
-  const auto* ptr1 = pipeline1.get();
-
-  Script s;
-  Result r = s.AddPipeline(std::move(pipeline1));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  auto pipeline2 = MakeUnique<Pipeline>(PipelineType::kGraphics);
-  pipeline2->SetName("my_pipeline2");
-
-  const auto* ptr2 = pipeline2.get();
-
-  r = s.AddPipeline(std::move(pipeline2));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  const auto& pipelines = s.GetPipelines();
-  ASSERT_EQ(2U, pipelines.size());
-  EXPECT_EQ(ptr1, pipelines[0].get());
-  EXPECT_EQ(ptr2, pipelines[1].get());
-}
-
-TEST_F(ScriptTest, AddDataBuffer) {
-  auto buffer = MakeUnique<DataBuffer>(BufferType::kStorage);
-  buffer->SetName("my_buffer");
-
-  Script s;
-  Result r = s.AddBuffer(std::move(buffer));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-}
-
-TEST_F(ScriptTest, AddDuplicateDataBuffer) {
-  auto buffer1 = MakeUnique<DataBuffer>(BufferType::kStorage);
-  buffer1->SetName("my_buffer");
-
-  Script s;
-  Result r = s.AddBuffer(std::move(buffer1));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  auto buffer2 = MakeUnique<DataBuffer>(BufferType::kUniform);
-  buffer2->SetName("my_buffer");
-
-  r = s.AddBuffer(std::move(buffer2));
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("duplicate buffer name provided", r.Error());
-}
-
-TEST_F(ScriptTest, GetDataBuffer) {
-  auto buffer = MakeUnique<DataBuffer>(BufferType::kStorage);
-  buffer->SetName("my_buffer");
-
-  const auto* ptr = buffer.get();
-
-  Script s;
-  Result r = s.AddBuffer(std::move(buffer));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  EXPECT_EQ(ptr, s.GetBuffer("my_buffer"));
-}
-
-TEST_F(ScriptTest, GetMissingBuffer) {
-  Script s;
-  EXPECT_TRUE(s.GetBuffer("my_buffer") == nullptr);
-}
-
-TEST_F(ScriptTest, GetBuffersEmpty) {
-  Script s;
-  const auto& buffers = s.GetBuffers();
-  EXPECT_TRUE(buffers.empty());
-}
-
-TEST_F(ScriptTest, GetBuffers) {
-  auto buffer1 = MakeUnique<DataBuffer>(BufferType::kStorage);
-  buffer1->SetName("my_buffer1");
-
-  const auto* ptr1 = buffer1.get();
-
-  Script s;
-  Result r = s.AddBuffer(std::move(buffer1));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  auto buffer2 = MakeUnique<DataBuffer>(BufferType::kUniform);
-  buffer2->SetName("my_buffer2");
-
-  const auto* ptr2 = buffer2.get();
-
-  r = s.AddBuffer(std::move(buffer2));
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  const auto& buffers = s.GetBuffers();
-  ASSERT_EQ(2U, buffers.size());
-  EXPECT_EQ(ptr1, buffers[0].get());
-  EXPECT_EQ(ptr2, buffers[1].get());
-}
-
-}  // namespace amberscript
-}  // namespace amber
diff --git a/src/engine.h b/src/engine.h
index 4ee149f..b45ed36 100644
--- a/src/engine.h
+++ b/src/engine.h
@@ -25,14 +25,10 @@
 #include "src/command.h"
 #include "src/feature.h"
 #include "src/format.h"
+#include "src/pipeline.h"
 
 namespace amber {
 
-enum class PipelineType : uint8_t {
-  kCompute = 0,
-  kGraphics,
-};
-
 enum class ResourceInfoType : uint8_t {
   kBuffer = 0,
   kImage,
diff --git a/src/executor.cc b/src/executor.cc
index 249a89f..c6f8eae 100644
--- a/src/executor.cc
+++ b/src/executor.cc
@@ -14,10 +14,144 @@
 
 #include "src/executor.h"
 
+#include <cassert>
+#include <vector>
+
+#include "src/engine.h"
+#include "src/script.h"
+#include "src/shader_compiler.h"
+
 namespace amber {
 
 Executor::Executor() = default;
 
 Executor::~Executor() = default;
 
+Result Executor::Execute(Engine* engine,
+                         const amber::Script* script,
+                         const ShaderMap& shader_map) {
+  engine->SetEngineData(script->GetEngineData());
+
+  // Process Shader nodes
+  PipelineType pipeline_type = PipelineType::kGraphics;
+  for (const auto& shader : script->GetShaders()) {
+    ShaderCompiler sc;
+
+    Result r;
+    std::vector<uint32_t> data;
+    std::tie(r, data) = sc.Compile(shader.get(), shader_map);
+    if (!r.IsSuccess())
+      return r;
+
+    r = engine->SetShader(shader->GetType(), data);
+    if (!r.IsSuccess())
+      return r;
+
+    if (shader->GetType() == ShaderType::kCompute)
+      pipeline_type = PipelineType::kCompute;
+  }
+
+  // Handle Image and Depth buffers early so they are available when we call
+  // the CreatePipeline method.
+  for (const auto& buf : script->GetBuffers()) {
+    // Image and depth are handled earler. They will be moved to the pipeline
+    // object when it exists.
+    if (buf->GetBufferType() != BufferType::kColor &&
+        buf->GetBufferType() != BufferType::kDepth) {
+      continue;
+    }
+
+    Result r = engine->SetBuffer(
+        buf->GetBufferType(), buf->GetLocation(),
+        buf->IsFormatBuffer() ? buf->AsFormatBuffer()->GetFormat() : Format(),
+        buf->GetData());
+    if (!r.IsSuccess())
+      return r;
+  }
+
+  // TODO(jaebaek): Support multiple pipelines.
+  Result r = engine->CreatePipeline(pipeline_type);
+  if (!r.IsSuccess())
+    return r;
+
+  // Process Buffers
+  for (const auto& buf : script->GetBuffers()) {
+    // Image and depth are handled earler. They will be moved to the pipeline
+    // object when it exists.
+    if (buf->GetBufferType() == BufferType::kColor ||
+        buf->GetBufferType() == BufferType::kDepth) {
+      continue;
+    }
+
+    r = engine->SetBuffer(
+        buf->GetBufferType(), buf->GetLocation(),
+        buf->IsFormatBuffer() ? buf->AsFormatBuffer()->GetFormat() : Format(),
+        buf->GetData());
+    if (!r.IsSuccess())
+      return r;
+  }
+
+  // Process Commands
+  for (const auto& cmd : script->GetCommands()) {
+    if (cmd->IsProbe()) {
+      ResourceInfo info;
+
+      r = engine->DoProcessCommands();
+      if (!r.IsSuccess())
+        return r;
+
+      // This must come after processing commands because we require
+      // the frambuffer buffer to be mapped into host memory and have
+      // a valid host-side pointer.
+      r = engine->GetFrameBufferInfo(&info);
+      if (!r.IsSuccess())
+        return r;
+      assert(info.cpu_memory != nullptr);
+
+      r = verifier_.Probe(cmd->AsProbe(), info.image_info.texel_stride,
+                          info.image_info.row_stride, info.image_info.width,
+                          info.image_info.height, info.cpu_memory);
+    } else if (cmd->IsProbeSSBO()) {
+      auto probe_ssbo = cmd->AsProbeSSBO();
+      ResourceInfo info;
+      r = engine->GetDescriptorInfo(probe_ssbo->GetDescriptorSet(),
+                                    probe_ssbo->GetBinding(), &info);
+      if (!r.IsSuccess())
+        return r;
+
+      r = engine->DoProcessCommands();
+      if (!r.IsSuccess())
+        return r;
+
+      r = verifier_.ProbeSSBO(probe_ssbo, info.size_in_bytes, info.cpu_memory);
+    } else if (cmd->IsClear()) {
+      r = engine->DoClear(cmd->AsClear());
+    } else if (cmd->IsClearColor()) {
+      r = engine->DoClearColor(cmd->AsClearColor());
+    } else if (cmd->IsClearDepth()) {
+      r = engine->DoClearDepth(cmd->AsClearDepth());
+    } else if (cmd->IsClearStencil()) {
+      r = engine->DoClearStencil(cmd->AsClearStencil());
+    } else if (cmd->IsDrawRect()) {
+      r = engine->DoDrawRect(cmd->AsDrawRect());
+    } else if (cmd->IsDrawArrays()) {
+      r = engine->DoDrawArrays(cmd->AsDrawArrays());
+    } else if (cmd->IsCompute()) {
+      r = engine->DoCompute(cmd->AsCompute());
+    } else if (cmd->IsEntryPoint()) {
+      r = engine->DoEntryPoint(cmd->AsEntryPoint());
+    } else if (cmd->IsPatchParameterVertices()) {
+      r = engine->DoPatchParameterVertices(cmd->AsPatchParameterVertices());
+    } else if (cmd->IsBuffer()) {
+      r = engine->DoBuffer(cmd->AsBuffer());
+    } else {
+      return Result("Unknown command type");
+    }
+
+    if (!r.IsSuccess())
+      return r;
+  }
+  return {};
+}
+
 }  // namespace amber
diff --git a/src/executor.h b/src/executor.h
index b2ba7e5..1144b89 100644
--- a/src/executor.h
+++ b/src/executor.h
@@ -18,17 +18,19 @@
 #include "amber/result.h"
 #include "src/engine.h"
 #include "src/script.h"
+#include "src/verifier.h"
 
 namespace amber {
 
 class Executor {
  public:
-  virtual ~Executor();
+  Executor();
+  ~Executor();
 
-  virtual Result Execute(Engine*, const Script*, const ShaderMap&) = 0;
+  Result Execute(Engine*, const Script*, const ShaderMap&);
 
- protected:
-  Executor();
+ private:
+  Verifier verifier_;
 };
 
 }  // namespace amber
diff --git a/src/executor_test.cc b/src/executor_test.cc
new file mode 100644
index 0000000..5f8cbf7
--- /dev/null
+++ b/src/executor_test.cc
@@ -0,0 +1,992 @@
+// Copyright 2018 The Amber Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "src/engine.h"
+#include "src/executor.h"
+#include "src/make_unique.h"
+#include "src/vkscript/parser.h"
+
+namespace amber {
+namespace vkscript {
+namespace {
+
+class EngineStub : public Engine {
+ public:
+  EngineStub() : Engine() {}
+  ~EngineStub() override = default;
+
+  // Engine
+  Result Initialize(const std::vector<Feature>& features,
+                    const std::vector<std::string>& extensions) override {
+    features_ = features;
+    extensions_ = extensions;
+    return {};
+  }
+
+  Result InitializeWithConfig(EngineConfig*,
+                              const std::vector<Feature>&,
+                              const std::vector<std::string>&) override {
+    return {};
+  }
+
+  Result Shutdown() override { return {}; }
+
+  const std::vector<Feature>& GetFeatures() const { return features_; }
+  const std::vector<std::string>& GetExtensions() const { return extensions_; }
+  FormatType GetColorFrameFormat() const { return color_frame_format_; }
+  FormatType GetDepthFrameFormat() const { return depth_frame_format_; }
+  uint32_t GetFenceTimeoutMs() { return GetEngineData().fence_timeout_ms; }
+
+  Result CreatePipeline(PipelineType) override { return {}; }
+
+  void FailShaderCommand() { fail_shader_command_ = true; }
+  const std::vector<ShaderType>& GetShaderTypesSeen() const {
+    return shaders_seen_;
+  }
+  Result SetShader(ShaderType type, const std::vector<uint32_t>&) override {
+    if (fail_shader_command_)
+      return Result("shader command failed");
+
+    shaders_seen_.push_back(type);
+    return {};
+  }
+
+  uint8_t GetBufferCallCount() const { return buffer_call_count_; }
+  BufferType GetBufferType(size_t idx) const { return buffer_types_[idx]; }
+  uint8_t GetBufferLocation(size_t idx) const { return buffer_locations_[idx]; }
+  Format* GetBufferFormat(size_t idx) { return &(buffer_formats_[idx]); }
+  const std::vector<Value>& GetBufferValues(size_t idx) const {
+    return buffer_values_[idx];
+  }
+  Result SetBuffer(BufferType type,
+                   uint8_t location,
+                   const Format& format,
+                   const std::vector<Value>& data) override {
+    if (type == BufferType::kColor || type == BufferType::kDepth) {
+      if (type == BufferType::kColor)
+        color_frame_format_ = format.GetFormatType();
+      else if (type == BufferType::kDepth)
+        depth_frame_format_ = format.GetFormatType();
+      return {};
+    }
+
+    ++buffer_call_count_;
+    buffer_types_.push_back(type);
+    buffer_locations_.push_back(location);
+    buffer_formats_.push_back(format);
+    buffer_values_.push_back(data);
+    return {};
+  }
+
+  void FailClearColorCommand() { fail_clear_color_command_ = true; }
+  bool DidClearColorCommand() { return did_clear_color_command_ = true; }
+  ClearColorCommand* GetLastClearColorCommand() { return last_clear_color_; }
+  Result DoClearColor(const ClearColorCommand* cmd) override {
+    did_clear_color_command_ = true;
+
+    if (fail_clear_color_command_)
+      return Result("clear color command failed");
+
+    last_clear_color_ = const_cast<ClearColorCommand*>(cmd);
+    return {};
+  }
+
+  void FailClearStencilCommand() { fail_clear_stencil_command_ = true; }
+  bool DidClearStencilCommand() const { return did_clear_stencil_command_; }
+  Result DoClearStencil(const ClearStencilCommand*) override {
+    did_clear_stencil_command_ = true;
+
+    if (fail_clear_stencil_command_)
+      return Result("clear stencil command failed");
+
+    return {};
+  }
+
+  void FailClearDepthCommand() { fail_clear_depth_command_ = true; }
+  bool DidClearDepthCommand() const { return did_clear_depth_command_; }
+  Result DoClearDepth(const ClearDepthCommand*) override {
+    did_clear_depth_command_ = true;
+
+    if (fail_clear_depth_command_)
+      return Result("clear depth command failed");
+
+    return {};
+  }
+
+  void FailClearCommand() { fail_clear_command_ = true; }
+  bool DidClearCommand() const { return did_clear_command_; }
+  Result DoClear(const ClearCommand*) override {
+    did_clear_command_ = true;
+
+    if (fail_clear_command_)
+      return Result("clear command failed");
+    return {};
+  }
+
+  void FailDrawRectCommand() { fail_draw_rect_command_ = true; }
+  bool DidDrawRectCommand() const { return did_draw_rect_command_; }
+  Result DoDrawRect(const DrawRectCommand*) override {
+    did_draw_rect_command_ = true;
+
+    if (fail_draw_rect_command_)
+      return Result("draw rect command failed");
+    return {};
+  }
+
+  void FailDrawArraysCommand() { fail_draw_arrays_command_ = true; }
+  bool DidDrawArraysCommand() const { return did_draw_arrays_command_; }
+  Result DoDrawArrays(const DrawArraysCommand*) override {
+    did_draw_arrays_command_ = true;
+
+    if (fail_draw_arrays_command_)
+      return Result("draw arrays command failed");
+    return {};
+  }
+
+  void FailComputeCommand() { fail_compute_command_ = true; }
+  bool DidComputeCommand() const { return did_compute_command_; }
+  Result DoCompute(const ComputeCommand*) override {
+    did_compute_command_ = true;
+
+    if (fail_compute_command_)
+      return Result("compute command failed");
+    return {};
+  }
+
+  void FailEntryPointCommand() { fail_entry_point_command_ = true; }
+  bool DidEntryPointCommand() const { return did_entry_point_command_; }
+  Result DoEntryPoint(const EntryPointCommand*) override {
+    did_entry_point_command_ = true;
+
+    if (fail_entry_point_command_)
+      return Result("entrypoint command failed");
+    return {};
+  }
+
+  void FailPatchParameterVerticesCommand() { fail_patch_command_ = true; }
+  bool DidPatchParameterVerticesCommand() const { return did_patch_command_; }
+  Result DoPatchParameterVertices(
+      const PatchParameterVerticesCommand*) override {
+    did_patch_command_ = true;
+
+    if (fail_patch_command_)
+      return Result("patch command failed");
+    return {};
+  }
+
+  void FailBufferCommand() { fail_buffer_command_ = true; }
+  bool DidBufferCommand() const { return did_buffer_command_; }
+  Result DoBuffer(const BufferCommand*) override {
+    did_buffer_command_ = true;
+
+    if (fail_buffer_command_)
+      return Result("buffer command failed");
+    return {};
+  }
+
+  Result DoProcessCommands() override { return {}; }
+  Result GetFrameBufferInfo(ResourceInfo*) override { return {}; }
+  Result GetDescriptorInfo(const uint32_t,
+                           const uint32_t,
+                           ResourceInfo*) override {
+    return {};
+  }
+
+ private:
+  bool fail_shader_command_ = false;
+  bool fail_clear_command_ = false;
+  bool fail_clear_color_command_ = false;
+  bool fail_clear_stencil_command_ = false;
+  bool fail_clear_depth_command_ = false;
+  bool fail_draw_rect_command_ = false;
+  bool fail_draw_arrays_command_ = false;
+  bool fail_compute_command_ = false;
+  bool fail_entry_point_command_ = false;
+  bool fail_patch_command_ = false;
+  bool fail_buffer_command_ = false;
+
+  bool did_clear_command_ = false;
+  bool did_clear_color_command_ = false;
+  bool did_clear_stencil_command_ = false;
+  bool did_clear_depth_command_ = false;
+  bool did_draw_rect_command_ = false;
+  bool did_draw_arrays_command_ = false;
+  bool did_compute_command_ = false;
+  bool did_entry_point_command_ = false;
+  bool did_patch_command_ = false;
+  bool did_buffer_command_ = false;
+
+  uint8_t buffer_call_count_ = 0;
+  std::vector<uint8_t> buffer_locations_;
+  std::vector<BufferType> buffer_types_;
+  std::vector<Format> buffer_formats_;
+  std::vector<std::vector<Value>> buffer_values_;
+
+  std::vector<ShaderType> shaders_seen_;
+  FormatType color_frame_format_ = FormatType::kUnknown;
+  FormatType depth_frame_format_ = FormatType::kUnknown;
+  std::vector<Feature> features_;
+  std::vector<std::string> extensions_;
+
+  ClearColorCommand* last_clear_color_ = nullptr;
+};
+
+class VkScriptExecutorTest : public testing::Test {
+ public:
+  VkScriptExecutorTest() = default;
+  ~VkScriptExecutorTest() = default;
+
+  std::unique_ptr<Engine> MakeEngine() { return MakeUnique<EngineStub>(); }
+  std::unique_ptr<Engine> MakeAndInitializeEngine(
+      const std::vector<Feature>& features,
+      const std::vector<std::string>& extensions) {
+    auto engine = MakeUnique<EngineStub>();
+    engine->Initialize(features, extensions);
+    return std::move(engine);
+  }
+  EngineStub* ToStub(Engine* engine) {
+    return static_cast<EngineStub*>(engine);
+  }
+};
+
+}  // namespace
+
+TEST_F(VkScriptExecutorTest, ExecutesRequiredFeatures) {
+  std::string input = R"(
+[require]
+robustBufferAccess
+logicOp)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto script = parser.GetScript();
+  auto engine = MakeAndInitializeEngine(script->RequiredFeatures(),
+                                        script->RequiredExtensions());
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+
+  const auto& features = ToStub(engine.get())->GetFeatures();
+  ASSERT_EQ(2U, features.size());
+  EXPECT_EQ(Feature::kRobustBufferAccess, features[0]);
+  EXPECT_EQ(Feature::kLogicOp, features[1]);
+
+  const auto& extensions = ToStub(engine.get())->GetExtensions();
+  ASSERT_EQ(0U, extensions.size());
+
+  EXPECT_EQ(100U, ToStub(engine.get())->GetFenceTimeoutMs());
+
+  auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
+  auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
+  EXPECT_EQ(FormatType::kUnknown, color_frame_format);
+  EXPECT_EQ(FormatType::kUnknown, depth_frame_format);
+}
+
+TEST_F(VkScriptExecutorTest, ExecutesRequiredExtensions) {
+  std::string input = R"(
+[require]
+VK_KHR_storage_buffer_storage_class
+VK_KHR_variable_pointers)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto script = parser.GetScript();
+  auto engine = MakeAndInitializeEngine(script->RequiredFeatures(),
+                                        script->RequiredExtensions());
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+
+  const auto& features = ToStub(engine.get())->GetFeatures();
+  ASSERT_EQ(0U, features.size());
+
+  const auto& extensions = ToStub(engine.get())->GetExtensions();
+  ASSERT_EQ(2U, extensions.size());
+  EXPECT_EQ("VK_KHR_storage_buffer_storage_class", extensions[0]);
+  EXPECT_EQ("VK_KHR_variable_pointers", extensions[1]);
+
+  EXPECT_EQ(100U, ToStub(engine.get())->GetFenceTimeoutMs());
+
+  auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
+  auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
+  EXPECT_EQ(FormatType::kUnknown, color_frame_format);
+  EXPECT_EQ(FormatType::kUnknown, depth_frame_format);
+}
+
+TEST_F(VkScriptExecutorTest, ExecutesRequiredFrameBuffers) {
+  std::string input = R"(
+[require]
+framebuffer R32G32B32A32_SFLOAT
+depthstencil D24_UNORM_S8_UINT)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto script = parser.GetScript();
+  auto engine = MakeAndInitializeEngine(script->RequiredFeatures(),
+                                        script->RequiredExtensions());
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+
+  const auto& features = ToStub(engine.get())->GetFeatures();
+  ASSERT_EQ(0U, features.size());
+
+  const auto& extensions = ToStub(engine.get())->GetExtensions();
+  ASSERT_EQ(0U, extensions.size());
+
+  EXPECT_EQ(100U, ToStub(engine.get())->GetFenceTimeoutMs());
+
+  auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
+  auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
+  EXPECT_EQ(FormatType::kR32G32B32A32_SFLOAT, color_frame_format);
+  EXPECT_EQ(FormatType::kD24_UNORM_S8_UINT, depth_frame_format);
+}
+
+TEST_F(VkScriptExecutorTest, ExecutesRequiredFenceTimeout) {
+  std::string input = R"(
+[require]
+fence_timeout 12345)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto script = parser.GetScript();
+  auto engine = MakeAndInitializeEngine(script->RequiredFeatures(),
+                                        script->RequiredExtensions());
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+
+  const auto& features = ToStub(engine.get())->GetFeatures();
+  ASSERT_EQ(0U, features.size());
+
+  const auto& extensions = ToStub(engine.get())->GetExtensions();
+  ASSERT_EQ(0U, extensions.size());
+
+  EXPECT_EQ(12345U, ToStub(engine.get())->GetFenceTimeoutMs());
+
+  auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
+  auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
+  EXPECT_EQ(FormatType::kUnknown, color_frame_format);
+  EXPECT_EQ(FormatType::kUnknown, depth_frame_format);
+}
+
+TEST_F(VkScriptExecutorTest, ExecutesRequiredAll) {
+  std::string input = R"(
+[require]
+robustBufferAccess
+logicOp
+VK_KHR_storage_buffer_storage_class
+VK_KHR_variable_pointers
+framebuffer R32G32B32A32_SFLOAT
+depthstencil D24_UNORM_S8_UINT
+fence_timeout 12345)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto script = parser.GetScript();
+  auto engine = MakeAndInitializeEngine(script->RequiredFeatures(),
+                                        script->RequiredExtensions());
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+
+  const auto& features = ToStub(engine.get())->GetFeatures();
+  ASSERT_EQ(2U, features.size());
+  EXPECT_EQ(Feature::kRobustBufferAccess, features[0]);
+  EXPECT_EQ(Feature::kLogicOp, features[1]);
+
+  const auto& extensions = ToStub(engine.get())->GetExtensions();
+  ASSERT_EQ(2U, extensions.size());
+  EXPECT_EQ("VK_KHR_storage_buffer_storage_class", extensions[0]);
+  EXPECT_EQ("VK_KHR_variable_pointers", extensions[1]);
+
+  EXPECT_EQ(12345U, ToStub(engine.get())->GetFenceTimeoutMs());
+
+  auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
+  auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
+  EXPECT_EQ(FormatType::kR32G32B32A32_SFLOAT, color_frame_format);
+  EXPECT_EQ(FormatType::kD24_UNORM_S8_UINT, depth_frame_format);
+}
+
+#if AMBER_ENABLE_SHADERC
+TEST_F(VkScriptExecutorTest, ExecutesShaders) {
+  std::string input = R"(
+[vertex shader passthrough]
+[fragment shader]
+#version 430
+void main() {}
+)";
+
+  Parser parser;
+  Result r = parser.Parse(input);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+
+  auto shader_types = ToStub(engine.get())->GetShaderTypesSeen();
+  ASSERT_EQ(2U, shader_types.size());
+  EXPECT_EQ(ShaderType::kVertex, shader_types[0]);
+  EXPECT_EQ(ShaderType::kFragment, shader_types[1]);
+}
+
+TEST_F(VkScriptExecutorTest, ShaderFailure) {
+  std::string input = R"(
+[vertex shader passthrough]
+[fragment shader]
+#version 430
+void main() {}
+)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  ToStub(engine.get())->FailShaderCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("shader command failed", r.Error());
+}
+#endif  // AMBER_ENABLE_SHADERC
+
+TEST_F(VkScriptExecutorTest, ClearCommand) {
+  std::string input = R"(
+[test]
+clear)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  EXPECT_TRUE(ToStub(engine.get())->DidClearCommand());
+}
+
+TEST_F(VkScriptExecutorTest, ClearCommandFailure) {
+  std::string input = R"(
+[test]
+clear)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  ToStub(engine.get())->FailClearCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("clear command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, ClearColorCommand) {
+  std::string input = R"(
+[test]
+clear color 244 123 123 13)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  ASSERT_TRUE(ToStub(engine.get())->DidClearColorCommand());
+
+  auto* cmd = ToStub(engine.get())->GetLastClearColorCommand();
+  ASSERT_TRUE(cmd != nullptr);
+  ASSERT_TRUE(cmd->IsClearColor());
+
+  EXPECT_EQ(244U, cmd->GetR());
+  EXPECT_EQ(123U, cmd->GetG());
+  EXPECT_EQ(123U, cmd->GetB());
+  EXPECT_EQ(13U, cmd->GetA());
+}
+
+TEST_F(VkScriptExecutorTest, ClearColorCommandFailure) {
+  std::string input = R"(
+[test]
+clear color 123 123 123 123)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  ToStub(engine.get())->FailClearColorCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("clear color command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, ClearDepthCommand) {
+  std::string input = R"(
+[test]
+clear depth 24)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  ASSERT_TRUE(ToStub(engine.get())->DidClearDepthCommand());
+}
+
+TEST_F(VkScriptExecutorTest, ClearDepthCommandFailure) {
+  std::string input = R"(
+[test]
+clear depth 24)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  ToStub(engine.get())->FailClearDepthCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("clear depth command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, ClearStencilCommand) {
+  std::string input = R"(
+[test]
+clear stencil 24)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  ASSERT_TRUE(ToStub(engine.get())->DidClearStencilCommand());
+}
+
+TEST_F(VkScriptExecutorTest, ClearStencilCommandFailure) {
+  std::string input = R"(
+[test]
+clear stencil 24)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  ToStub(engine.get())->FailClearStencilCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("clear stencil command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, DrawRectCommand) {
+  std::string input = R"(
+[test]
+draw rect 2 4 10 20)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  ASSERT_TRUE(ToStub(engine.get())->DidDrawRectCommand());
+}
+
+TEST_F(VkScriptExecutorTest, DrawRectCommandFailure) {
+  std::string input = R"(
+[test]
+draw rect 2 4 10 20)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  ToStub(engine.get())->FailDrawRectCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("draw rect command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, DrawArraysCommand) {
+  std::string input = R"(
+[test]
+draw arrays TRIANGLE_LIST 0 0)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  ASSERT_TRUE(ToStub(engine.get())->DidDrawArraysCommand());
+}
+
+TEST_F(VkScriptExecutorTest, DrawArraysCommandFailure) {
+  std::string input = R"(
+[test]
+draw arrays TRIANGLE_LIST 0 0)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  ToStub(engine.get())->FailDrawArraysCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("draw arrays command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, ComputeCommand) {
+  std::string input = R"(
+[test]
+compute 2 3 4)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  ASSERT_TRUE(ToStub(engine.get())->DidComputeCommand());
+}
+
+TEST_F(VkScriptExecutorTest, ComputeCommandFailure) {
+  std::string input = R"(
+[test]
+compute 2 3 4)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  ToStub(engine.get())->FailComputeCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("compute command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, EntryPointCommand) {
+  std::string input = R"(
+[test]
+vertex entrypoint main)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  ASSERT_TRUE(ToStub(engine.get())->DidEntryPointCommand());
+}
+
+TEST_F(VkScriptExecutorTest, EntryPointCommandFailure) {
+  std::string input = R"(
+[test]
+vertex entrypoint main)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  ToStub(engine.get())->FailEntryPointCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("entrypoint command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, PatchParameterVerticesCommand) {
+  std::string input = R"(
+[test]
+patch parameter vertices 10)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  ASSERT_TRUE(ToStub(engine.get())->DidPatchParameterVerticesCommand());
+}
+
+TEST_F(VkScriptExecutorTest, PatchParameterVerticesCommandFailure) {
+  std::string input = R"(
+[test]
+patch parameter vertices 10)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  ToStub(engine.get())->FailPatchParameterVerticesCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("patch command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, DISABLED_ProbeCommand) {
+  std::string input = R"(
+[test]
+probe rect rgba 2 3 40 40 0.2 0.4 0.4 0.3)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  // ASSERT_TRUE(ToStub(engine.get())->DidProbeCommand());
+}
+
+TEST_F(VkScriptExecutorTest, DISABLED_ProbeCommandFailure) {
+  std::string input = R"(
+[test]
+probe rect rgba 2 3 40 40 0.2 0.4 0.4 0.3)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  // ToStub(engine.get())->FailProbeCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("probe command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, BufferCommand) {
+  std::string input = R"(
+[test]
+ssbo 0 24)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  ASSERT_TRUE(ToStub(engine.get())->DidBufferCommand());
+}
+
+TEST_F(VkScriptExecutorTest, BufferCommandFailure) {
+  std::string input = R"(
+[test]
+ssbo 0 24)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  ToStub(engine.get())->FailBufferCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("buffer command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, DISABLED_ProbeSSBOCommand) {
+  std::string input = R"(
+[test]
+probe ssbo vec3 0 2 <= 2 3 4)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+  // ASSERT_TRUE(ToStub(engine.get())->DidProbeSSBOCommand());
+}
+
+TEST_F(VkScriptExecutorTest, DISABLED_ProbeSSBOCommandFailure) {
+  std::string input = R"(
+[test]
+probe ssbo vec3 0 2 <= 2 3 4)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+
+  auto engine = MakeEngine();
+  // ToStub(engine.get())->FailProbeSSBOCommand();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("probe ssbo command failed", r.Error());
+}
+
+TEST_F(VkScriptExecutorTest, VertexData) {
+  std::string input = R"(
+[vertex data]
+9/R32G32B32_SFLOAT  1/R8G8B8_UNORM
+-1    -1 0.25       255 128 64
+0.25  -1 0.25       255 0 0
+)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+
+  auto stub = ToStub(engine.get());
+  ASSERT_EQ(2U, stub->GetBufferCallCount());
+
+  EXPECT_EQ(FormatType::kR32G32B32_SFLOAT,
+            stub->GetBufferFormat(0)->GetFormatType());
+  EXPECT_EQ(BufferType::kVertex, stub->GetBufferType(0));
+  EXPECT_EQ(9U, stub->GetBufferLocation(0));
+
+  const auto& data1 = stub->GetBufferValues(0);
+  std::vector<float> results1 = {-1, -1, 0.25, 0.25, -1, 0.25};
+  ASSERT_EQ(results1.size(), data1.size());
+  for (size_t i = 0; i < results1.size(); ++i) {
+    ASSERT_TRUE(data1[i].IsFloat());
+    EXPECT_FLOAT_EQ(results1[i], data1[i].AsFloat());
+  }
+
+  EXPECT_EQ(FormatType::kR8G8B8_UNORM,
+            stub->GetBufferFormat(1)->GetFormatType());
+  EXPECT_EQ(BufferType::kVertex, stub->GetBufferType(1));
+  EXPECT_EQ(1U, stub->GetBufferLocation(1));
+
+  const auto& data2 = stub->GetBufferValues(1);
+  std::vector<uint8_t> results2 = {255, 128, 64, 255, 0, 0};
+  ASSERT_EQ(results2.size(), data2.size());
+  for (size_t i = 0; i < results2.size(); ++i) {
+    ASSERT_TRUE(data2[i].IsInteger());
+    EXPECT_EQ(results2[i], data2[i].AsUint8());
+  }
+}
+
+TEST_F(VkScriptExecutorTest, IndexBuffer) {
+  std::string input = R"(
+[indices]
+1 2 3 4 5 6
+)";
+
+  Parser parser;
+  ASSERT_TRUE(parser.Parse(input).IsSuccess());
+  auto engine = MakeEngine();
+  auto script = parser.GetScript();
+
+  Executor ex;
+  Result r = ex.Execute(engine.get(), script.get(), ShaderMap());
+  ASSERT_TRUE(r.IsSuccess());
+
+  auto stub = ToStub(engine.get());
+  ASSERT_EQ(1U, stub->GetBufferCallCount());
+
+  EXPECT_EQ(BufferType::kIndex, stub->GetBufferType(0));
+
+  const auto& data = stub->GetBufferValues(0);
+  std::vector<uint8_t> results = {1, 2, 3, 4, 5, 6};
+  ASSERT_EQ(results.size(), data.size());
+  for (size_t i = 0; i < results.size(); ++i) {
+    ASSERT_TRUE(data[i].IsInteger());
+    EXPECT_EQ(results[i], data[i].AsUint8());
+  }
+}
+
+}  // namespace vkscript
+}  // namespace amber
diff --git a/src/pipeline.cc b/src/pipeline.cc
new file mode 100644
index 0000000..fa94dd5
--- /dev/null
+++ b/src/pipeline.cc
@@ -0,0 +1,142 @@
+// Copyright 2018 The Amber Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/pipeline.h"
+
+#include <algorithm>
+#include <set>
+
+namespace amber {
+
+Pipeline::ShaderInfo::ShaderInfo(const Shader* shader)
+    : shader_(shader), entry_point_("main") {}
+
+Pipeline::ShaderInfo::ShaderInfo(const ShaderInfo&) = default;
+
+Pipeline::ShaderInfo::~ShaderInfo() = default;
+
+Pipeline::Pipeline(PipelineType type) : pipeline_type_(type) {}
+
+Pipeline::~Pipeline() = default;
+
+Result Pipeline::AddShader(const Shader* shader) {
+  if (!shader)
+    return Result("shader can not be null when attached to pipeline");
+
+  if (pipeline_type_ == PipelineType::kCompute &&
+      shader->GetType() != ShaderType::kCompute) {
+    return Result("only compute shaders allowed in a compute pipeline");
+  }
+  if (pipeline_type_ == PipelineType::kGraphics &&
+      shader->GetType() == ShaderType::kCompute) {
+    return Result("can not add a compute shader to a graphics pipeline");
+  }
+
+  for (const auto& info : shaders_) {
+    const auto* is = info.GetShader();
+    if (is == shader)
+      return Result("can not add duplicate shader to pipeline");
+    if (is->GetType() == shader->GetType())
+      return Result("can not add duplicate shader type to pipeline");
+  }
+
+  shaders_.emplace_back(shader);
+  return {};
+}
+
+Result Pipeline::SetShaderOptimizations(const Shader* shader,
+                                        const std::vector<std::string>& opts) {
+  if (!shader)
+    return Result("invalid shader specified for optimizations");
+
+  std::set<std::string> seen;
+  for (const auto& opt : opts) {
+    if (seen.count(opt) != 0)
+      return Result("duplicate optimization flag (" + opt + ") set on shader");
+
+    seen.insert(opt);
+  }
+
+  for (auto& info : shaders_) {
+    const auto* is = info.GetShader();
+    if (is == shader) {
+      info.SetShaderOptimizations(opts);
+      return {};
+    }
+  }
+
+  return Result("unknown shader specified for optimizations: " +
+                shader->GetName());
+}
+
+Result Pipeline::SetShaderEntryPoint(const Shader* shader,
+                                     const std::string& name) {
+  if (!shader)
+    return Result("invalid shader specified for entry point");
+  if (name.empty())
+    return Result("entry point should not be blank");
+
+  for (auto& info : shaders_) {
+    if (info.GetShader() == shader) {
+      if (info.GetEntryPoint() != "main")
+        return Result("multiple entry points given for the same shader");
+
+      info.SetEntryPoint(name);
+      return {};
+    }
+  }
+
+  return Result("unknown shader specified for entry point: " +
+                shader->GetName());
+}
+
+Result Pipeline::Validate() const {
+  if (pipeline_type_ == PipelineType::kGraphics)
+    return ValidateGraphics();
+  return ValidateCompute();
+}
+
+Result Pipeline::ValidateGraphics() const {
+  if (shaders_.empty())
+    return Result("graphics pipeline requires vertex and fragment shaders");
+
+  bool found_vertex = false;
+  bool found_fragment = false;
+  for (const auto& info : shaders_) {
+    const auto* is = info.GetShader();
+    if (is->GetType() == ShaderType::kVertex)
+      found_vertex = true;
+    if (is->GetType() == ShaderType::kFragment)
+      found_fragment = true;
+    if (found_vertex && found_fragment)
+      break;
+  }
+
+  if (!found_vertex && !found_fragment)
+    return Result("graphics pipeline requires vertex and fragment shaders");
+  if (!found_vertex)
+    return Result("graphics pipeline requires a vertex shader");
+  if (!found_fragment)
+    return Result("graphics pipeline requires a fragment shader");
+  return {};
+}
+
+Result Pipeline::ValidateCompute() const {
+  if (shaders_.empty())
+    return Result("compute pipeline requires a compute shader");
+
+  return {};
+}
+
+}  // namespace amber
diff --git a/src/pipeline.h b/src/pipeline.h
new file mode 100644
index 0000000..881ecc6
--- /dev/null
+++ b/src/pipeline.h
@@ -0,0 +1,83 @@
+// Copyright 2018 The Amber Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_PIPELINE_H_
+#define SRC_PIPELINE_H_
+
+#include <string>
+#include <vector>
+
+#include "amber/result.h"
+#include "src/shader.h"
+
+namespace amber {
+
+enum class PipelineType { kCompute = 0, kGraphics };
+
+class Pipeline {
+ public:
+  class ShaderInfo {
+   public:
+    explicit ShaderInfo(const Shader*);
+    ShaderInfo(const ShaderInfo&);
+    ~ShaderInfo();
+
+    void SetShaderOptimizations(const std::vector<std::string>& opts) {
+      shader_optimizations_ = opts;
+    }
+    const std::vector<std::string>& GetShaderOptimizations() const {
+      return shader_optimizations_;
+    }
+
+    const Shader* GetShader() const { return shader_; }
+
+    void SetEntryPoint(const std::string& ep) { entry_point_ = ep; }
+    std::string GetEntryPoint() const { return entry_point_; }
+
+   private:
+    const Shader* shader_ = nullptr;
+    std::vector<std::string> shader_optimizations_;
+    std::string entry_point_;
+  };
+
+  explicit Pipeline(PipelineType type);
+  ~Pipeline();
+
+  PipelineType GetType() const { return pipeline_type_; }
+
+  void SetName(const std::string& name) { name_ = name; }
+  const std::string& GetName() const { return name_; }
+
+  Result AddShader(const Shader*);
+  const std::vector<ShaderInfo>& GetShaders() const { return shaders_; }
+
+  Result SetShaderEntryPoint(const Shader* shader, const std::string& name);
+  Result SetShaderOptimizations(const Shader* shader,
+                                const std::vector<std::string>& opts);
+
+  // Validates that the pipeline has been created correctly.
+  Result Validate() const;
+
+ private:
+  Result ValidateGraphics() const;
+  Result ValidateCompute() const;
+
+  PipelineType pipeline_type_ = PipelineType::kCompute;
+  std::string name_;
+  std::vector<ShaderInfo> shaders_;
+};
+
+}  // namespace amber
+
+#endif  // SRC_PIPELINE_H_
diff --git a/src/pipeline_test.cc b/src/pipeline_test.cc
new file mode 100644
index 0000000..3902baf
--- /dev/null
+++ b/src/pipeline_test.cc
@@ -0,0 +1,331 @@
+// Copyright 2018 The Amber Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/pipeline.h"
+#include "gtest/gtest.h"
+
+namespace amber {
+namespace {
+
+struct ShaderTypeData {
+  ShaderType type;
+};
+
+}  // namespace
+
+using AmberScriptPipelineTest = testing::Test;
+
+TEST_F(AmberScriptPipelineTest, AddShader) {
+  Shader v(ShaderType::kVertex);
+  Shader f(ShaderType::kFragment);
+
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.AddShader(&v);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.AddShader(&f);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  const auto& shaders = p.GetShaders();
+  EXPECT_EQ(2U, shaders.size());
+
+  EXPECT_EQ(&v, shaders[0].GetShader());
+  EXPECT_EQ(&f, shaders[1].GetShader());
+}
+
+TEST_F(AmberScriptPipelineTest, MissingShader) {
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.AddShader(nullptr);
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("shader can not be null when attached to pipeline", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, DuplicateShaders) {
+  Shader v(ShaderType::kVertex);
+  Shader f(ShaderType::kFragment);
+
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.AddShader(&v);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.AddShader(&f);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.AddShader(&v);
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("can not add duplicate shader to pipeline", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, DuplicateShaderType) {
+  Shader v(ShaderType::kVertex);
+  Shader f(ShaderType::kVertex);
+
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.AddShader(&v);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.AddShader(&f);
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("can not add duplicate shader type to pipeline", r.Error());
+}
+
+using AmberScriptPipelineComputePipelineTest =
+    testing::TestWithParam<ShaderTypeData>;
+TEST_P(AmberScriptPipelineComputePipelineTest,
+       SettingGraphicsShaderToComputePipeline) {
+  const auto test_data = GetParam();
+
+  Shader s(test_data.type);
+
+  Pipeline p(PipelineType::kCompute);
+  Result r = p.AddShader(&s);
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("only compute shaders allowed in a compute pipeline", r.Error());
+}
+INSTANTIATE_TEST_CASE_P(
+    AmberScriptPipelineComputePipelineTests,
+    AmberScriptPipelineComputePipelineTest,
+    testing::Values(
+        ShaderTypeData{ShaderType::kVertex},
+        ShaderTypeData{ShaderType::kFragment},
+        ShaderTypeData{ShaderType::kGeometry},
+        ShaderTypeData{ShaderType::kTessellationEvaluation},
+        ShaderTypeData{
+            ShaderType::kTessellationControl}), );  // NOLINT(whitespace/parens)
+
+TEST_F(AmberScriptPipelineTest, SettingComputeShaderToGraphicsPipeline) {
+  Shader c(ShaderType::kCompute);
+
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.AddShader(&c);
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("can not add a compute shader to a graphics pipeline", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, SetShaderOptimizations) {
+  Shader v(ShaderType::kVertex);
+  Shader f(ShaderType::kFragment);
+
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.AddShader(&v);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.AddShader(&f);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  std::vector<std::string> first = {"First", "Second"};
+  std::vector<std::string> second = {"Third", "Forth"};
+
+  r = p.SetShaderOptimizations(&f, first);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.SetShaderOptimizations(&v, second);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  const auto& shaders = p.GetShaders();
+  EXPECT_EQ(2U, shaders.size());
+  EXPECT_EQ(second, shaders[0].GetShaderOptimizations());
+  EXPECT_EQ(first, shaders[1].GetShaderOptimizations());
+}
+
+TEST_F(AmberScriptPipelineTest, DuplicateShaderOptimizations) {
+  Shader v(ShaderType::kVertex);
+
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.AddShader(&v);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  std::vector<std::string> data = {"One", "One"};
+  r = p.SetShaderOptimizations(&v, data);
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("duplicate optimization flag (One) set on shader", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, SetOptimizationForMissingShader) {
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.SetShaderOptimizations(nullptr, {"One", "Two"});
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("invalid shader specified for optimizations", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, SetOptimizationForInvalidShader) {
+  Shader v(ShaderType::kVertex);
+  v.SetName("my_shader");
+
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.SetShaderOptimizations(&v, {"One", "Two"});
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("unknown shader specified for optimizations: my_shader", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest,
+       GraphicsPipelineRequiresVertexAndFragmentShader) {
+  Shader v(ShaderType::kVertex);
+  Shader f(ShaderType::kFragment);
+  Shader g(ShaderType::kGeometry);
+
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.AddShader(&v);
+  EXPECT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.AddShader(&g);
+  EXPECT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.AddShader(&f);
+  EXPECT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.Validate();
+  EXPECT_TRUE(r.IsSuccess()) << r.Error();
+}
+
+TEST_F(AmberScriptPipelineTest, GraphicsPipelineMissingFragmentShader) {
+  Shader v(ShaderType::kVertex);
+  Shader g(ShaderType::kGeometry);
+
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.AddShader(&v);
+  EXPECT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.AddShader(&g);
+  EXPECT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.Validate();
+  EXPECT_FALSE(r.IsSuccess()) << r.Error();
+  EXPECT_EQ("graphics pipeline requires a fragment shader", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, GraphicsPipelineMissingVertexShader) {
+  Shader f(ShaderType::kFragment);
+  Shader g(ShaderType::kGeometry);
+
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.AddShader(&g);
+  EXPECT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.AddShader(&f);
+  EXPECT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.Validate();
+  EXPECT_FALSE(r.IsSuccess()) << r.Error();
+  EXPECT_EQ("graphics pipeline requires a vertex shader", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest,
+       GraphicsPipelineMissingVertexAndFragmentShader) {
+  Shader g(ShaderType::kGeometry);
+
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.AddShader(&g);
+  EXPECT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.Validate();
+  EXPECT_FALSE(r.IsSuccess()) << r.Error();
+  EXPECT_EQ("graphics pipeline requires vertex and fragment shaders",
+            r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, GraphicsPipelineWihoutShaders) {
+  Pipeline p(PipelineType::kGraphics);
+  Result r = p.Validate();
+  EXPECT_FALSE(r.IsSuccess()) << r.Error();
+  EXPECT_EQ("graphics pipeline requires vertex and fragment shaders",
+            r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, ComputePipelineRequiresComputeShader) {
+  Shader c(ShaderType::kCompute);
+
+  Pipeline p(PipelineType::kCompute);
+  Result r = p.AddShader(&c);
+  EXPECT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.Validate();
+  EXPECT_TRUE(r.IsSuccess()) << r.Error();
+}
+
+TEST_F(AmberScriptPipelineTest, ComputePipelineWithoutShader) {
+  Pipeline p(PipelineType::kCompute);
+  Result r = p.Validate();
+  EXPECT_FALSE(r.IsSuccess()) << r.Error();
+  EXPECT_EQ("compute pipeline requires a compute shader", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, SetEntryPointForMissingShader) {
+  Shader c(ShaderType::kCompute);
+  c.SetName("my_shader");
+
+  Pipeline p(PipelineType::kCompute);
+  Result r = p.SetShaderEntryPoint(&c, "test");
+  EXPECT_FALSE(r.IsSuccess());
+  EXPECT_EQ("unknown shader specified for entry point: my_shader", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, SetEntryPointForNullShader) {
+  Pipeline p(PipelineType::kCompute);
+  Result r = p.SetShaderEntryPoint(nullptr, "test");
+  EXPECT_FALSE(r.IsSuccess());
+  EXPECT_EQ("invalid shader specified for entry point", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, SetBlankEntryPoint) {
+  Shader c(ShaderType::kCompute);
+  Pipeline p(PipelineType::kCompute);
+  Result r = p.AddShader(&c);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.SetShaderEntryPoint(&c, "");
+  EXPECT_FALSE(r.IsSuccess());
+  EXPECT_EQ("entry point should not be blank", r.Error());
+}
+
+TEST_F(AmberScriptPipelineTest, ShaderDefaultEntryPoint) {
+  Shader c(ShaderType::kCompute);
+  Pipeline p(PipelineType::kCompute);
+  Result r = p.AddShader(&c);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  const auto& shaders = p.GetShaders();
+  ASSERT_EQ(1U, shaders.size());
+  EXPECT_EQ("main", shaders[0].GetEntryPoint());
+}
+
+TEST_F(AmberScriptPipelineTest, SetShaderEntryPoint) {
+  Shader c(ShaderType::kCompute);
+  Pipeline p(PipelineType::kCompute);
+  Result r = p.AddShader(&c);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.SetShaderEntryPoint(&c, "my_main");
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  const auto& shaders = p.GetShaders();
+  ASSERT_EQ(1U, shaders.size());
+  EXPECT_EQ("my_main", shaders[0].GetEntryPoint());
+}
+
+TEST_F(AmberScriptPipelineTest, SetEntryPointMulitpleTimes) {
+  Shader c(ShaderType::kCompute);
+  Pipeline p(PipelineType::kCompute);
+  Result r = p.AddShader(&c);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.SetShaderEntryPoint(&c, "my_main");
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  r = p.SetShaderEntryPoint(&c, "another_main");
+  EXPECT_FALSE(r.IsSuccess());
+  EXPECT_EQ("multiple entry points given for the same shader", r.Error());
+}
+
+}  // namespace amber
diff --git a/src/script.cc b/src/script.cc
index 3685cfc..978df32 100644
--- a/src/script.cc
+++ b/src/script.cc
@@ -16,7 +16,7 @@
 
 namespace amber {
 
-Script::Script(ScriptType type) : script_type_(type) {}
+Script::Script() = default;
 
 Script::~Script() = default;
 
diff --git a/src/script.h b/src/script.h
index 024ca9c..1ebab3a 100644
--- a/src/script.h
+++ b/src/script.h
@@ -28,22 +28,35 @@
 #include "src/command.h"
 #include "src/engine.h"
 #include "src/feature.h"
+#include "src/pipeline.h"
 #include "src/shader.h"
 
 namespace amber {
 
-enum class ScriptType : uint8_t { kVkScript = 0, kAmberScript };
-
 class Script : public RecipeImpl {
  public:
+  Script();
   ~Script() override;
 
-  bool IsVkScript() const { return script_type_ == ScriptType::kVkScript; }
-  bool IsAmberScript() const {
-    return script_type_ == ScriptType::kAmberScript;
+  std::vector<ShaderInfo> GetShaderInfo() const override;
+
+  Result AddPipeline(std::unique_ptr<Pipeline> pipeline) {
+    if (name_to_pipeline_.count(pipeline->GetName()) > 0)
+      return Result("duplicate pipeline name provided");
+
+    pipelines_.push_back(std::move(pipeline));
+    name_to_pipeline_[pipelines_.back()->GetName()] = pipelines_.back().get();
+    return {};
   }
 
-  std::vector<ShaderInfo> GetShaderInfo() const override;
+  Pipeline* GetPipeline(const std::string& name) const {
+    auto it = name_to_pipeline_.find(name);
+    return it == name_to_pipeline_.end() ? nullptr : it->second;
+  }
+
+  const std::vector<std::unique_ptr<Pipeline>>& GetPipelines() const {
+    return pipelines_;
+  }
 
   Result AddShader(std::unique_ptr<Shader> shader) {
     if (name_to_shader_.count(shader->GetName()) > 0)
@@ -72,6 +85,11 @@ class Script : public RecipeImpl {
     return {};
   }
 
+  Buffer* GetBuffer(const std::string& name) const {
+    auto it = name_to_buffer_.find(name);
+    return it == name_to_buffer_.end() ? nullptr : it->second;
+  }
+
   const std::vector<std::unique_ptr<Buffer>>& GetBuffers() const {
     return buffers_;
   }
@@ -100,22 +118,20 @@ class Script : public RecipeImpl {
     return commands_;
   }
 
- protected:
-  explicit Script(ScriptType);
-
  private:
   struct {
     std::vector<Feature> required_features;
     std::vector<std::string> required_extensions;
   } engine_info_;
 
-  ScriptType script_type_;
   EngineData engine_data_;
   std::map<std::string, Shader*> name_to_shader_;
   std::map<std::string, Buffer*> name_to_buffer_;
+  std::map<std::string, Pipeline*> name_to_pipeline_;
   std::vector<std::unique_ptr<Shader>> shaders_;
   std::vector<std::unique_ptr<Command>> commands_;
   std::vector<std::unique_ptr<Buffer>> buffers_;
+  std::vector<std::unique_ptr<Pipeline>> pipelines_;
 };
 
 }  // namespace amber
diff --git a/src/script_test.cc b/src/script_test.cc
index 41f611f..4bc9e75 100644
--- a/src/script_test.cc
+++ b/src/script_test.cc
@@ -25,7 +25,7 @@ namespace {
 
 class ScriptProxy : public Script {
  public:
-  ScriptProxy() : Script(ScriptType::kVkScript) {}
+  ScriptProxy() = default;
   ~ScriptProxy() override = default;
 };
 
@@ -70,4 +70,222 @@ TEST_F(ScriptTest, GetShaderInfoNoShaders) {
   EXPECT_TRUE(info.empty());
 }
 
+TEST_F(ScriptTest, AddShader) {
+  auto shader = MakeUnique<Shader>(ShaderType::kVertex);
+  shader->SetName("My Shader");
+
+  Script s;
+  Result r = s.AddShader(std::move(shader));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+}
+
+TEST_F(ScriptTest, AddDuplicateShader) {
+  auto shader1 = MakeUnique<Shader>(ShaderType::kVertex);
+  shader1->SetName("My Shader");
+
+  Script s;
+  Result r = s.AddShader(std::move(shader1));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  auto shader2 = MakeUnique<Shader>(ShaderType::kFragment);
+  shader2->SetName("My Shader");
+
+  r = s.AddShader(std::move(shader2));
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("duplicate shader name provided", r.Error());
+}
+
+TEST_F(ScriptTest, GetShader) {
+  auto shader = MakeUnique<Shader>(ShaderType::kVertex);
+  shader->SetName("My Shader");
+
+  auto* ptr = shader.get();
+
+  Script s;
+  Result r = s.AddShader(std::move(shader));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  EXPECT_EQ(ptr, s.GetShader("My Shader"));
+}
+
+TEST_F(ScriptTest, GetMissingShader) {
+  Script s;
+  EXPECT_TRUE(s.GetShader("My Shader") == nullptr);
+}
+
+TEST_F(ScriptTest, GetShadersEmpty) {
+  Script s;
+  const auto& shaders = s.GetShaders();
+  EXPECT_TRUE(shaders.empty());
+}
+
+TEST_F(ScriptTest, GetShaders) {
+  auto shader1 = MakeUnique<Shader>(ShaderType::kVertex);
+  shader1->SetName("My Shader");
+
+  const auto* ptr1 = shader1.get();
+
+  Script s;
+  Result r = s.AddShader(std::move(shader1));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  auto shader2 = MakeUnique<Shader>(ShaderType::kFragment);
+  shader2->SetName("My Fragment");
+
+  const auto* ptr2 = shader2.get();
+
+  r = s.AddShader(std::move(shader2));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  const auto& shaders = s.GetShaders();
+  ASSERT_EQ(2U, shaders.size());
+  EXPECT_EQ(ptr1, shaders[0].get());
+  EXPECT_EQ(ptr2, shaders[1].get());
+}
+
+TEST_F(ScriptTest, AddPipeline) {
+  auto pipeline = MakeUnique<Pipeline>(PipelineType::kCompute);
+  pipeline->SetName("my_pipeline");
+
+  Script s;
+  Result r = s.AddPipeline(std::move(pipeline));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+}
+
+TEST_F(ScriptTest, AddDuplicatePipeline) {
+  auto pipeline1 = MakeUnique<Pipeline>(PipelineType::kCompute);
+  pipeline1->SetName("my_pipeline");
+
+  Script s;
+  Result r = s.AddPipeline(std::move(pipeline1));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  auto pipeline2 = MakeUnique<Pipeline>(PipelineType::kGraphics);
+  pipeline2->SetName("my_pipeline");
+  r = s.AddPipeline(std::move(pipeline2));
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("duplicate pipeline name provided", r.Error());
+}
+
+TEST_F(ScriptTest, GetPipeline) {
+  auto pipeline = MakeUnique<Pipeline>(PipelineType::kCompute);
+  pipeline->SetName("my_pipeline");
+
+  const auto* ptr = pipeline.get();
+
+  Script s;
+  Result r = s.AddPipeline(std::move(pipeline));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  EXPECT_EQ(ptr, s.GetPipeline("my_pipeline"));
+}
+
+TEST_F(ScriptTest, GetMissingPipeline) {
+  Script s;
+  EXPECT_TRUE(s.GetPipeline("my_pipeline") == nullptr);
+}
+
+TEST_F(ScriptTest, GetPipelinesEmpty) {
+  Script s;
+  const auto& pipelines = s.GetPipelines();
+  EXPECT_TRUE(pipelines.empty());
+}
+
+TEST_F(ScriptTest, GetPipelines) {
+  auto pipeline1 = MakeUnique<Pipeline>(PipelineType::kCompute);
+  pipeline1->SetName("my_pipeline1");
+
+  const auto* ptr1 = pipeline1.get();
+
+  Script s;
+  Result r = s.AddPipeline(std::move(pipeline1));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  auto pipeline2 = MakeUnique<Pipeline>(PipelineType::kGraphics);
+  pipeline2->SetName("my_pipeline2");
+
+  const auto* ptr2 = pipeline2.get();
+
+  r = s.AddPipeline(std::move(pipeline2));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  const auto& pipelines = s.GetPipelines();
+  ASSERT_EQ(2U, pipelines.size());
+  EXPECT_EQ(ptr1, pipelines[0].get());
+  EXPECT_EQ(ptr2, pipelines[1].get());
+}
+
+TEST_F(ScriptTest, AddDataBuffer) {
+  auto buffer = MakeUnique<DataBuffer>(BufferType::kStorage);
+  buffer->SetName("my_buffer");
+
+  Script s;
+  Result r = s.AddBuffer(std::move(buffer));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+}
+
+TEST_F(ScriptTest, AddDuplicateDataBuffer) {
+  auto buffer1 = MakeUnique<DataBuffer>(BufferType::kStorage);
+  buffer1->SetName("my_buffer");
+
+  Script s;
+  Result r = s.AddBuffer(std::move(buffer1));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  auto buffer2 = MakeUnique<DataBuffer>(BufferType::kUniform);
+  buffer2->SetName("my_buffer");
+
+  r = s.AddBuffer(std::move(buffer2));
+  ASSERT_FALSE(r.IsSuccess());
+  EXPECT_EQ("duplicate buffer name provided", r.Error());
+}
+
+TEST_F(ScriptTest, GetDataBuffer) {
+  auto buffer = MakeUnique<DataBuffer>(BufferType::kStorage);
+  buffer->SetName("my_buffer");
+
+  const auto* ptr = buffer.get();
+
+  Script s;
+  Result r = s.AddBuffer(std::move(buffer));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  EXPECT_EQ(ptr, s.GetBuffer("my_buffer"));
+}
+
+TEST_F(ScriptTest, GetMissingBuffer) {
+  Script s;
+  EXPECT_TRUE(s.GetBuffer("my_buffer") == nullptr);
+}
+
+TEST_F(ScriptTest, GetBuffersEmpty) {
+  Script s;
+  const auto& buffers = s.GetBuffers();
+  EXPECT_TRUE(buffers.empty());
+}
+
+TEST_F(ScriptTest, GetBuffers) {
+  auto buffer1 = MakeUnique<DataBuffer>(BufferType::kStorage);
+  buffer1->SetName("my_buffer1");
+
+  const auto* ptr1 = buffer1.get();
+
+  Script s;
+  Result r = s.AddBuffer(std::move(buffer1));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  auto buffer2 = MakeUnique<DataBuffer>(BufferType::kUniform);
+  buffer2->SetName("my_buffer2");
+
+  const auto* ptr2 = buffer2.get();
+
+  r = s.AddBuffer(std::move(buffer2));
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  const auto& buffers = s.GetBuffers();
+  ASSERT_EQ(2U, buffers.size());
+  EXPECT_EQ(ptr1, buffers[0].get());
+  EXPECT_EQ(ptr2, buffers[1].get());
+}
+
 }  // namespace amber
diff --git a/src/vkscript/executor.cc b/src/vkscript/executor.cc
deleted file mode 100644
index 1bed156..0000000
--- a/src/vkscript/executor.cc
+++ /dev/null
@@ -1,162 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/vkscript/executor.h"
-
-#include <cassert>
-#include <vector>
-
-#include "src/engine.h"
-#include "src/shader_compiler.h"
-#include "src/vkscript/script.h"
-
-namespace amber {
-namespace vkscript {
-
-Executor::Executor() : amber::Executor() {}
-
-Executor::~Executor() = default;
-
-Result Executor::Execute(Engine* engine,
-                         const amber::Script* script,
-                         const ShaderMap& shader_map) {
-  if (!script->IsVkScript())
-    return Result("VkScript Executor called with non-vkscript source");
-
-  engine->SetEngineData(script->GetEngineData());
-
-  // Process Shader nodes
-  PipelineType pipeline_type = PipelineType::kGraphics;
-  for (const auto& shader : script->GetShaders()) {
-    ShaderCompiler sc;
-
-    Result r;
-    std::vector<uint32_t> data;
-    std::tie(r, data) = sc.Compile(shader.get(), shader_map);
-    if (!r.IsSuccess())
-      return r;
-
-    r = engine->SetShader(shader->GetType(), data);
-    if (!r.IsSuccess())
-      return r;
-
-    if (shader->GetType() == ShaderType::kCompute)
-      pipeline_type = PipelineType::kCompute;
-  }
-
-  // Handle Image and Depth buffers early so they are available when we call
-  // the CreatePipeline method.
-  for (const auto& buf : script->GetBuffers()) {
-    // Image and depth are handled earler. They will be moved to the pipeline
-    // object when it exists.
-    if (buf->GetBufferType() != BufferType::kColor &&
-        buf->GetBufferType() != BufferType::kDepth) {
-      continue;
-    }
-
-    Result r = engine->SetBuffer(
-        buf->GetBufferType(), buf->GetLocation(),
-        buf->IsFormatBuffer() ? buf->AsFormatBuffer()->GetFormat() : Format(),
-        buf->GetData());
-    if (!r.IsSuccess())
-      return r;
-  }
-
-  // TODO(jaebaek): Support multiple pipelines.
-  Result r = engine->CreatePipeline(pipeline_type);
-  if (!r.IsSuccess())
-    return r;
-
-  // Process Buffers
-  for (const auto& buf : script->GetBuffers()) {
-    // Image and depth are handled earler. They will be moved to the pipeline
-    // object when it exists.
-    if (buf->GetBufferType() == BufferType::kColor ||
-        buf->GetBufferType() == BufferType::kDepth) {
-      continue;
-    }
-
-    r = engine->SetBuffer(
-        buf->GetBufferType(), buf->GetLocation(),
-        buf->IsFormatBuffer() ? buf->AsFormatBuffer()->GetFormat() : Format(),
-        buf->GetData());
-    if (!r.IsSuccess())
-      return r;
-  }
-
-  // Process Commands
-  for (const auto& cmd : script->GetCommands()) {
-    if (cmd->IsProbe()) {
-      ResourceInfo info;
-
-      r = engine->DoProcessCommands();
-      if (!r.IsSuccess())
-        return r;
-
-      // This must come after processing commands because we require
-      // the frambuffer buffer to be mapped into host memory and have
-      // a valid host-side pointer.
-      r = engine->GetFrameBufferInfo(&info);
-      if (!r.IsSuccess())
-        return r;
-      assert(info.cpu_memory != nullptr);
-
-      r = verifier_.Probe(cmd->AsProbe(), info.image_info.texel_stride,
-                          info.image_info.row_stride, info.image_info.width,
-                          info.image_info.height, info.cpu_memory);
-    } else if (cmd->IsProbeSSBO()) {
-      auto probe_ssbo = cmd->AsProbeSSBO();
-      ResourceInfo info;
-      r = engine->GetDescriptorInfo(probe_ssbo->GetDescriptorSet(),
-                                    probe_ssbo->GetBinding(), &info);
-      if (!r.IsSuccess())
-        return r;
-
-      r = engine->DoProcessCommands();
-      if (!r.IsSuccess())
-        return r;
-
-      r = verifier_.ProbeSSBO(probe_ssbo, info.size_in_bytes, info.cpu_memory);
-    } else if (cmd->IsClear()) {
-      r = engine->DoClear(cmd->AsClear());
-    } else if (cmd->IsClearColor()) {
-      r = engine->DoClearColor(cmd->AsClearColor());
-    } else if (cmd->IsClearDepth()) {
-      r = engine->DoClearDepth(cmd->AsClearDepth());
-    } else if (cmd->IsClearStencil()) {
-      r = engine->DoClearStencil(cmd->AsClearStencil());
-    } else if (cmd->IsDrawRect()) {
-      r = engine->DoDrawRect(cmd->AsDrawRect());
-    } else if (cmd->IsDrawArrays()) {
-      r = engine->DoDrawArrays(cmd->AsDrawArrays());
-    } else if (cmd->IsCompute()) {
-      r = engine->DoCompute(cmd->AsCompute());
-    } else if (cmd->IsEntryPoint()) {
-      r = engine->DoEntryPoint(cmd->AsEntryPoint());
-    } else if (cmd->IsPatchParameterVertices()) {
-      r = engine->DoPatchParameterVertices(cmd->AsPatchParameterVertices());
-    } else if (cmd->IsBuffer()) {
-      r = engine->DoBuffer(cmd->AsBuffer());
-    } else {
-      return Result("Unknown command type");
-    }
-
-    if (!r.IsSuccess())
-      return r;
-  }
-  return {};
-}
-
-}  // namespace vkscript
-}  // namespace amber
diff --git a/src/vkscript/executor.h b/src/vkscript/executor.h
deleted file mode 100644
index abbe978..0000000
--- a/src/vkscript/executor.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_VKSCRIPT_EXECUTOR_H_
-#define SRC_VKSCRIPT_EXECUTOR_H_
-
-#include "amber/result.h"
-#include "src/executor.h"
-#include "src/verifier.h"
-
-namespace amber {
-namespace vkscript {
-
-class Executor : public amber::Executor {
- public:
-  Executor();
-  ~Executor() override;
-
-  Result Execute(Engine*, const amber::Script*, const ShaderMap&) override;
-
- private:
-  Verifier verifier_;
-};
-
-}  // namespace vkscript
-}  // namespace amber
-
-#endif  // SRC_VKSCRIPT_EXECUTOR_H_
diff --git a/src/vkscript/executor_test.cc b/src/vkscript/executor_test.cc
deleted file mode 100644
index 8d51772..0000000
--- a/src/vkscript/executor_test.cc
+++ /dev/null
@@ -1,992 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "gtest/gtest.h"
-#include "src/engine.h"
-#include "src/make_unique.h"
-#include "src/vkscript/executor.h"
-#include "src/vkscript/parser.h"
-
-namespace amber {
-namespace vkscript {
-namespace {
-
-class EngineStub : public Engine {
- public:
-  EngineStub() : Engine() {}
-  ~EngineStub() override = default;
-
-  // Engine
-  Result Initialize(const std::vector<Feature>& features,
-                    const std::vector<std::string>& extensions) override {
-    features_ = features;
-    extensions_ = extensions;
-    return {};
-  }
-
-  Result InitializeWithConfig(EngineConfig*,
-                              const std::vector<Feature>&,
-                              const std::vector<std::string>&) override {
-    return {};
-  }
-
-  Result Shutdown() override { return {}; }
-
-  const std::vector<Feature>& GetFeatures() const { return features_; }
-  const std::vector<std::string>& GetExtensions() const { return extensions_; }
-  FormatType GetColorFrameFormat() const { return color_frame_format_; }
-  FormatType GetDepthFrameFormat() const { return depth_frame_format_; }
-  uint32_t GetFenceTimeoutMs() { return GetEngineData().fence_timeout_ms; }
-
-  Result CreatePipeline(PipelineType) override { return {}; }
-
-  void FailShaderCommand() { fail_shader_command_ = true; }
-  const std::vector<ShaderType>& GetShaderTypesSeen() const {
-    return shaders_seen_;
-  }
-  Result SetShader(ShaderType type, const std::vector<uint32_t>&) override {
-    if (fail_shader_command_)
-      return Result("shader command failed");
-
-    shaders_seen_.push_back(type);
-    return {};
-  }
-
-  uint8_t GetBufferCallCount() const { return buffer_call_count_; }
-  BufferType GetBufferType(size_t idx) const { return buffer_types_[idx]; }
-  uint8_t GetBufferLocation(size_t idx) const { return buffer_locations_[idx]; }
-  Format* GetBufferFormat(size_t idx) { return &(buffer_formats_[idx]); }
-  const std::vector<Value>& GetBufferValues(size_t idx) const {
-    return buffer_values_[idx];
-  }
-  Result SetBuffer(BufferType type,
-                   uint8_t location,
-                   const Format& format,
-                   const std::vector<Value>& data) override {
-    if (type == BufferType::kColor || type == BufferType::kDepth) {
-      if (type == BufferType::kColor)
-        color_frame_format_ = format.GetFormatType();
-      else if (type == BufferType::kDepth)
-        depth_frame_format_ = format.GetFormatType();
-      return {};
-    }
-
-    ++buffer_call_count_;
-    buffer_types_.push_back(type);
-    buffer_locations_.push_back(location);
-    buffer_formats_.push_back(format);
-    buffer_values_.push_back(data);
-    return {};
-  }
-
-  void FailClearColorCommand() { fail_clear_color_command_ = true; }
-  bool DidClearColorCommand() { return did_clear_color_command_ = true; }
-  ClearColorCommand* GetLastClearColorCommand() { return last_clear_color_; }
-  Result DoClearColor(const ClearColorCommand* cmd) override {
-    did_clear_color_command_ = true;
-
-    if (fail_clear_color_command_)
-      return Result("clear color command failed");
-
-    last_clear_color_ = const_cast<ClearColorCommand*>(cmd);
-    return {};
-  }
-
-  void FailClearStencilCommand() { fail_clear_stencil_command_ = true; }
-  bool DidClearStencilCommand() const { return did_clear_stencil_command_; }
-  Result DoClearStencil(const ClearStencilCommand*) override {
-    did_clear_stencil_command_ = true;
-
-    if (fail_clear_stencil_command_)
-      return Result("clear stencil command failed");
-
-    return {};
-  }
-
-  void FailClearDepthCommand() { fail_clear_depth_command_ = true; }
-  bool DidClearDepthCommand() const { return did_clear_depth_command_; }
-  Result DoClearDepth(const ClearDepthCommand*) override {
-    did_clear_depth_command_ = true;
-
-    if (fail_clear_depth_command_)
-      return Result("clear depth command failed");
-
-    return {};
-  }
-
-  void FailClearCommand() { fail_clear_command_ = true; }
-  bool DidClearCommand() const { return did_clear_command_; }
-  Result DoClear(const ClearCommand*) override {
-    did_clear_command_ = true;
-
-    if (fail_clear_command_)
-      return Result("clear command failed");
-    return {};
-  }
-
-  void FailDrawRectCommand() { fail_draw_rect_command_ = true; }
-  bool DidDrawRectCommand() const { return did_draw_rect_command_; }
-  Result DoDrawRect(const DrawRectCommand*) override {
-    did_draw_rect_command_ = true;
-
-    if (fail_draw_rect_command_)
-      return Result("draw rect command failed");
-    return {};
-  }
-
-  void FailDrawArraysCommand() { fail_draw_arrays_command_ = true; }
-  bool DidDrawArraysCommand() const { return did_draw_arrays_command_; }
-  Result DoDrawArrays(const DrawArraysCommand*) override {
-    did_draw_arrays_command_ = true;
-
-    if (fail_draw_arrays_command_)
-      return Result("draw arrays command failed");
-    return {};
-  }
-
-  void FailComputeCommand() { fail_compute_command_ = true; }
-  bool DidComputeCommand() const { return did_compute_command_; }
-  Result DoCompute(const ComputeCommand*) override {
-    did_compute_command_ = true;
-
-    if (fail_compute_command_)
-      return Result("compute command failed");
-    return {};
-  }
-
-  void FailEntryPointCommand() { fail_entry_point_command_ = true; }
-  bool DidEntryPointCommand() const { return did_entry_point_command_; }
-  Result DoEntryPoint(const EntryPointCommand*) override {
-    did_entry_point_command_ = true;
-
-    if (fail_entry_point_command_)
-      return Result("entrypoint command failed");
-    return {};
-  }
-
-  void FailPatchParameterVerticesCommand() { fail_patch_command_ = true; }
-  bool DidPatchParameterVerticesCommand() const { return did_patch_command_; }
-  Result DoPatchParameterVertices(
-      const PatchParameterVerticesCommand*) override {
-    did_patch_command_ = true;
-
-    if (fail_patch_command_)
-      return Result("patch command failed");
-    return {};
-  }
-
-  void FailBufferCommand() { fail_buffer_command_ = true; }
-  bool DidBufferCommand() const { return did_buffer_command_; }
-  Result DoBuffer(const BufferCommand*) override {
-    did_buffer_command_ = true;
-
-    if (fail_buffer_command_)
-      return Result("buffer command failed");
-    return {};
-  }
-
-  Result DoProcessCommands() override { return {}; }
-  Result GetFrameBufferInfo(ResourceInfo*) override { return {}; }
-  Result GetDescriptorInfo(const uint32_t,
-                           const uint32_t,
-                           ResourceInfo*) override {
-    return {};
-  }
-
- private:
-  bool fail_shader_command_ = false;
-  bool fail_clear_command_ = false;
-  bool fail_clear_color_command_ = false;
-  bool fail_clear_stencil_command_ = false;
-  bool fail_clear_depth_command_ = false;
-  bool fail_draw_rect_command_ = false;
-  bool fail_draw_arrays_command_ = false;
-  bool fail_compute_command_ = false;
-  bool fail_entry_point_command_ = false;
-  bool fail_patch_command_ = false;
-  bool fail_buffer_command_ = false;
-
-  bool did_clear_command_ = false;
-  bool did_clear_color_command_ = false;
-  bool did_clear_stencil_command_ = false;
-  bool did_clear_depth_command_ = false;
-  bool did_draw_rect_command_ = false;
-  bool did_draw_arrays_command_ = false;
-  bool did_compute_command_ = false;
-  bool did_entry_point_command_ = false;
-  bool did_patch_command_ = false;
-  bool did_buffer_command_ = false;
-
-  uint8_t buffer_call_count_ = 0;
-  std::vector<uint8_t> buffer_locations_;
-  std::vector<BufferType> buffer_types_;
-  std::vector<Format> buffer_formats_;
-  std::vector<std::vector<Value>> buffer_values_;
-
-  std::vector<ShaderType> shaders_seen_;
-  FormatType color_frame_format_ = FormatType::kUnknown;
-  FormatType depth_frame_format_ = FormatType::kUnknown;
-  std::vector<Feature> features_;
-  std::vector<std::string> extensions_;
-
-  ClearColorCommand* last_clear_color_ = nullptr;
-};
-
-class VkScriptExecutorTest : public testing::Test {
- public:
-  VkScriptExecutorTest() = default;
-  ~VkScriptExecutorTest() = default;
-
-  std::unique_ptr<Engine> MakeEngine() { return MakeUnique<EngineStub>(); }
-  std::unique_ptr<Engine> MakeAndInitializeEngine(
-      const std::vector<Feature>& features,
-      const std::vector<std::string>& extensions) {
-    auto engine = MakeUnique<EngineStub>();
-    engine->Initialize(features, extensions);
-    return std::move(engine);
-  }
-  EngineStub* ToStub(Engine* engine) {
-    return static_cast<EngineStub*>(engine);
-  }
-};
-
-}  // namespace
-
-TEST_F(VkScriptExecutorTest, ExecutesRequiredFeatures) {
-  std::string input = R"(
-[require]
-robustBufferAccess
-logicOp)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto script = parser.GetScript();
-  auto engine = MakeAndInitializeEngine(script->RequiredFeatures(),
-                                        script->RequiredExtensions());
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-
-  const auto& features = ToStub(engine.get())->GetFeatures();
-  ASSERT_EQ(2U, features.size());
-  EXPECT_EQ(Feature::kRobustBufferAccess, features[0]);
-  EXPECT_EQ(Feature::kLogicOp, features[1]);
-
-  const auto& extensions = ToStub(engine.get())->GetExtensions();
-  ASSERT_EQ(0U, extensions.size());
-
-  EXPECT_EQ(100U, ToStub(engine.get())->GetFenceTimeoutMs());
-
-  auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
-  auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
-  EXPECT_EQ(FormatType::kUnknown, color_frame_format);
-  EXPECT_EQ(FormatType::kUnknown, depth_frame_format);
-}
-
-TEST_F(VkScriptExecutorTest, ExecutesRequiredExtensions) {
-  std::string input = R"(
-[require]
-VK_KHR_storage_buffer_storage_class
-VK_KHR_variable_pointers)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto script = parser.GetScript();
-  auto engine = MakeAndInitializeEngine(script->RequiredFeatures(),
-                                        script->RequiredExtensions());
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-
-  const auto& features = ToStub(engine.get())->GetFeatures();
-  ASSERT_EQ(0U, features.size());
-
-  const auto& extensions = ToStub(engine.get())->GetExtensions();
-  ASSERT_EQ(2U, extensions.size());
-  EXPECT_EQ("VK_KHR_storage_buffer_storage_class", extensions[0]);
-  EXPECT_EQ("VK_KHR_variable_pointers", extensions[1]);
-
-  EXPECT_EQ(100U, ToStub(engine.get())->GetFenceTimeoutMs());
-
-  auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
-  auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
-  EXPECT_EQ(FormatType::kUnknown, color_frame_format);
-  EXPECT_EQ(FormatType::kUnknown, depth_frame_format);
-}
-
-TEST_F(VkScriptExecutorTest, ExecutesRequiredFrameBuffers) {
-  std::string input = R"(
-[require]
-framebuffer R32G32B32A32_SFLOAT
-depthstencil D24_UNORM_S8_UINT)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto script = parser.GetScript();
-  auto engine = MakeAndInitializeEngine(script->RequiredFeatures(),
-                                        script->RequiredExtensions());
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-
-  const auto& features = ToStub(engine.get())->GetFeatures();
-  ASSERT_EQ(0U, features.size());
-
-  const auto& extensions = ToStub(engine.get())->GetExtensions();
-  ASSERT_EQ(0U, extensions.size());
-
-  EXPECT_EQ(100U, ToStub(engine.get())->GetFenceTimeoutMs());
-
-  auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
-  auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
-  EXPECT_EQ(FormatType::kR32G32B32A32_SFLOAT, color_frame_format);
-  EXPECT_EQ(FormatType::kD24_UNORM_S8_UINT, depth_frame_format);
-}
-
-TEST_F(VkScriptExecutorTest, ExecutesRequiredFenceTimeout) {
-  std::string input = R"(
-[require]
-fence_timeout 12345)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto script = parser.GetScript();
-  auto engine = MakeAndInitializeEngine(script->RequiredFeatures(),
-                                        script->RequiredExtensions());
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-
-  const auto& features = ToStub(engine.get())->GetFeatures();
-  ASSERT_EQ(0U, features.size());
-
-  const auto& extensions = ToStub(engine.get())->GetExtensions();
-  ASSERT_EQ(0U, extensions.size());
-
-  EXPECT_EQ(12345U, ToStub(engine.get())->GetFenceTimeoutMs());
-
-  auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
-  auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
-  EXPECT_EQ(FormatType::kUnknown, color_frame_format);
-  EXPECT_EQ(FormatType::kUnknown, depth_frame_format);
-}
-
-TEST_F(VkScriptExecutorTest, ExecutesRequiredAll) {
-  std::string input = R"(
-[require]
-robustBufferAccess
-logicOp
-VK_KHR_storage_buffer_storage_class
-VK_KHR_variable_pointers
-framebuffer R32G32B32A32_SFLOAT
-depthstencil D24_UNORM_S8_UINT
-fence_timeout 12345)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto script = parser.GetScript();
-  auto engine = MakeAndInitializeEngine(script->RequiredFeatures(),
-                                        script->RequiredExtensions());
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-
-  const auto& features = ToStub(engine.get())->GetFeatures();
-  ASSERT_EQ(2U, features.size());
-  EXPECT_EQ(Feature::kRobustBufferAccess, features[0]);
-  EXPECT_EQ(Feature::kLogicOp, features[1]);
-
-  const auto& extensions = ToStub(engine.get())->GetExtensions();
-  ASSERT_EQ(2U, extensions.size());
-  EXPECT_EQ("VK_KHR_storage_buffer_storage_class", extensions[0]);
-  EXPECT_EQ("VK_KHR_variable_pointers", extensions[1]);
-
-  EXPECT_EQ(12345U, ToStub(engine.get())->GetFenceTimeoutMs());
-
-  auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
-  auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
-  EXPECT_EQ(FormatType::kR32G32B32A32_SFLOAT, color_frame_format);
-  EXPECT_EQ(FormatType::kD24_UNORM_S8_UINT, depth_frame_format);
-}
-
-#if AMBER_ENABLE_SHADERC
-TEST_F(VkScriptExecutorTest, ExecutesShaders) {
-  std::string input = R"(
-[vertex shader passthrough]
-[fragment shader]
-#version 430
-void main() {}
-)";
-
-  Parser parser;
-  Result r = parser.Parse(input);
-  ASSERT_TRUE(r.IsSuccess()) << r.Error();
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-
-  auto shader_types = ToStub(engine.get())->GetShaderTypesSeen();
-  ASSERT_EQ(2U, shader_types.size());
-  EXPECT_EQ(ShaderType::kVertex, shader_types[0]);
-  EXPECT_EQ(ShaderType::kFragment, shader_types[1]);
-}
-
-TEST_F(VkScriptExecutorTest, ShaderFailure) {
-  std::string input = R"(
-[vertex shader passthrough]
-[fragment shader]
-#version 430
-void main() {}
-)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  ToStub(engine.get())->FailShaderCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("shader command failed", r.Error());
-}
-#endif  // AMBER_ENABLE_SHADERC
-
-TEST_F(VkScriptExecutorTest, ClearCommand) {
-  std::string input = R"(
-[test]
-clear)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  EXPECT_TRUE(ToStub(engine.get())->DidClearCommand());
-}
-
-TEST_F(VkScriptExecutorTest, ClearCommandFailure) {
-  std::string input = R"(
-[test]
-clear)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  ToStub(engine.get())->FailClearCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("clear command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, ClearColorCommand) {
-  std::string input = R"(
-[test]
-clear color 244 123 123 13)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  ASSERT_TRUE(ToStub(engine.get())->DidClearColorCommand());
-
-  auto* cmd = ToStub(engine.get())->GetLastClearColorCommand();
-  ASSERT_TRUE(cmd != nullptr);
-  ASSERT_TRUE(cmd->IsClearColor());
-
-  EXPECT_EQ(244U, cmd->GetR());
-  EXPECT_EQ(123U, cmd->GetG());
-  EXPECT_EQ(123U, cmd->GetB());
-  EXPECT_EQ(13U, cmd->GetA());
-}
-
-TEST_F(VkScriptExecutorTest, ClearColorCommandFailure) {
-  std::string input = R"(
-[test]
-clear color 123 123 123 123)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  ToStub(engine.get())->FailClearColorCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("clear color command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, ClearDepthCommand) {
-  std::string input = R"(
-[test]
-clear depth 24)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  ASSERT_TRUE(ToStub(engine.get())->DidClearDepthCommand());
-}
-
-TEST_F(VkScriptExecutorTest, ClearDepthCommandFailure) {
-  std::string input = R"(
-[test]
-clear depth 24)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  ToStub(engine.get())->FailClearDepthCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("clear depth command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, ClearStencilCommand) {
-  std::string input = R"(
-[test]
-clear stencil 24)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  ASSERT_TRUE(ToStub(engine.get())->DidClearStencilCommand());
-}
-
-TEST_F(VkScriptExecutorTest, ClearStencilCommandFailure) {
-  std::string input = R"(
-[test]
-clear stencil 24)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  ToStub(engine.get())->FailClearStencilCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("clear stencil command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, DrawRectCommand) {
-  std::string input = R"(
-[test]
-draw rect 2 4 10 20)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  ASSERT_TRUE(ToStub(engine.get())->DidDrawRectCommand());
-}
-
-TEST_F(VkScriptExecutorTest, DrawRectCommandFailure) {
-  std::string input = R"(
-[test]
-draw rect 2 4 10 20)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  ToStub(engine.get())->FailDrawRectCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("draw rect command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, DrawArraysCommand) {
-  std::string input = R"(
-[test]
-draw arrays TRIANGLE_LIST 0 0)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  ASSERT_TRUE(ToStub(engine.get())->DidDrawArraysCommand());
-}
-
-TEST_F(VkScriptExecutorTest, DrawArraysCommandFailure) {
-  std::string input = R"(
-[test]
-draw arrays TRIANGLE_LIST 0 0)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  ToStub(engine.get())->FailDrawArraysCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("draw arrays command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, ComputeCommand) {
-  std::string input = R"(
-[test]
-compute 2 3 4)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  ASSERT_TRUE(ToStub(engine.get())->DidComputeCommand());
-}
-
-TEST_F(VkScriptExecutorTest, ComputeCommandFailure) {
-  std::string input = R"(
-[test]
-compute 2 3 4)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  ToStub(engine.get())->FailComputeCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("compute command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, EntryPointCommand) {
-  std::string input = R"(
-[test]
-vertex entrypoint main)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  ASSERT_TRUE(ToStub(engine.get())->DidEntryPointCommand());
-}
-
-TEST_F(VkScriptExecutorTest, EntryPointCommandFailure) {
-  std::string input = R"(
-[test]
-vertex entrypoint main)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  ToStub(engine.get())->FailEntryPointCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("entrypoint command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, PatchParameterVerticesCommand) {
-  std::string input = R"(
-[test]
-patch parameter vertices 10)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  ASSERT_TRUE(ToStub(engine.get())->DidPatchParameterVerticesCommand());
-}
-
-TEST_F(VkScriptExecutorTest, PatchParameterVerticesCommandFailure) {
-  std::string input = R"(
-[test]
-patch parameter vertices 10)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  ToStub(engine.get())->FailPatchParameterVerticesCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("patch command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, DISABLED_ProbeCommand) {
-  std::string input = R"(
-[test]
-probe rect rgba 2 3 40 40 0.2 0.4 0.4 0.3)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  // ASSERT_TRUE(ToStub(engine.get())->DidProbeCommand());
-}
-
-TEST_F(VkScriptExecutorTest, DISABLED_ProbeCommandFailure) {
-  std::string input = R"(
-[test]
-probe rect rgba 2 3 40 40 0.2 0.4 0.4 0.3)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  // ToStub(engine.get())->FailProbeCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("probe command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, BufferCommand) {
-  std::string input = R"(
-[test]
-ssbo 0 24)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  ASSERT_TRUE(ToStub(engine.get())->DidBufferCommand());
-}
-
-TEST_F(VkScriptExecutorTest, BufferCommandFailure) {
-  std::string input = R"(
-[test]
-ssbo 0 24)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  ToStub(engine.get())->FailBufferCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("buffer command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, DISABLED_ProbeSSBOCommand) {
-  std::string input = R"(
-[test]
-probe ssbo vec3 0 2 <= 2 3 4)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-  // ASSERT_TRUE(ToStub(engine.get())->DidProbeSSBOCommand());
-}
-
-TEST_F(VkScriptExecutorTest, DISABLED_ProbeSSBOCommandFailure) {
-  std::string input = R"(
-[test]
-probe ssbo vec3 0 2 <= 2 3 4)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-
-  auto engine = MakeEngine();
-  // ToStub(engine.get())->FailProbeSSBOCommand();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_FALSE(r.IsSuccess());
-  EXPECT_EQ("probe ssbo command failed", r.Error());
-}
-
-TEST_F(VkScriptExecutorTest, VertexData) {
-  std::string input = R"(
-[vertex data]
-9/R32G32B32_SFLOAT  1/R8G8B8_UNORM
--1    -1 0.25       255 128 64
-0.25  -1 0.25       255 0 0
-)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-
-  auto stub = ToStub(engine.get());
-  ASSERT_EQ(2U, stub->GetBufferCallCount());
-
-  EXPECT_EQ(FormatType::kR32G32B32_SFLOAT,
-            stub->GetBufferFormat(0)->GetFormatType());
-  EXPECT_EQ(BufferType::kVertex, stub->GetBufferType(0));
-  EXPECT_EQ(9U, stub->GetBufferLocation(0));
-
-  const auto& data1 = stub->GetBufferValues(0);
-  std::vector<float> results1 = {-1, -1, 0.25, 0.25, -1, 0.25};
-  ASSERT_EQ(results1.size(), data1.size());
-  for (size_t i = 0; i < results1.size(); ++i) {
-    ASSERT_TRUE(data1[i].IsFloat());
-    EXPECT_FLOAT_EQ(results1[i], data1[i].AsFloat());
-  }
-
-  EXPECT_EQ(FormatType::kR8G8B8_UNORM,
-            stub->GetBufferFormat(1)->GetFormatType());
-  EXPECT_EQ(BufferType::kVertex, stub->GetBufferType(1));
-  EXPECT_EQ(1U, stub->GetBufferLocation(1));
-
-  const auto& data2 = stub->GetBufferValues(1);
-  std::vector<uint8_t> results2 = {255, 128, 64, 255, 0, 0};
-  ASSERT_EQ(results2.size(), data2.size());
-  for (size_t i = 0; i < results2.size(); ++i) {
-    ASSERT_TRUE(data2[i].IsInteger());
-    EXPECT_EQ(results2[i], data2[i].AsUint8());
-  }
-}
-
-TEST_F(VkScriptExecutorTest, IndexBuffer) {
-  std::string input = R"(
-[indices]
-1 2 3 4 5 6
-)";
-
-  Parser parser;
-  ASSERT_TRUE(parser.Parse(input).IsSuccess());
-  auto engine = MakeEngine();
-  auto script = parser.GetScript();
-
-  Executor ex;
-  Result r = ex.Execute(engine.get(), ToVkScript(script.get()), ShaderMap());
-  ASSERT_TRUE(r.IsSuccess());
-
-  auto stub = ToStub(engine.get());
-  ASSERT_EQ(1U, stub->GetBufferCallCount());
-
-  EXPECT_EQ(BufferType::kIndex, stub->GetBufferType(0));
-
-  const auto& data = stub->GetBufferValues(0);
-  std::vector<uint8_t> results = {1, 2, 3, 4, 5, 6};
-  ASSERT_EQ(results.size(), data.size());
-  for (size_t i = 0; i < results.size(); ++i) {
-    ASSERT_TRUE(data[i].IsInteger());
-    EXPECT_EQ(results[i], data[i].AsUint8());
-  }
-}
-
-}  // namespace vkscript
-}  // namespace amber
diff --git a/src/vkscript/parser.cc b/src/vkscript/parser.cc
index b375eed..d731911 100644
--- a/src/vkscript/parser.cc
+++ b/src/vkscript/parser.cc
@@ -153,7 +153,7 @@ Feature NameToFeature(const std::string& name) {
 
 }  // namespace
 
-Parser::Parser() : amber::Parser(), script_(MakeUnique<vkscript::Script>()) {}
+Parser::Parser() : amber::Parser(), script_(MakeUnique<Script>()) {}
 
 Parser::~Parser() = default;
 
diff --git a/src/vkscript/parser.h b/src/vkscript/parser.h
index 08a4fd6..2987ef7 100644
--- a/src/vkscript/parser.h
+++ b/src/vkscript/parser.h
@@ -21,7 +21,7 @@
 
 #include "amber/result.h"
 #include "src/parser.h"
-#include "src/vkscript/script.h"
+#include "src/script.h"
 #include "src/vkscript/section_parser.h"
 
 namespace amber {
@@ -34,9 +34,7 @@ class Parser : public amber::Parser {
 
   // amber::Parser
   Result Parse(const std::string& data) override;
-  std::unique_ptr<amber::Script> GetScript() override {
-    return std::move(script_);
-  }
+  std::unique_ptr<Script> GetScript() override { return std::move(script_); }
 
   Result ProcessRequireBlockForTesting(const std::string& block) {
     return ProcessRequireBlock(block);
@@ -59,7 +57,7 @@ class Parser : public amber::Parser {
   Result ProcessVertexDataBlock(const std::string&);
   Result ProcessTestBlock(const std::string&);
 
-  std::unique_ptr<vkscript::Script> script_;
+  std::unique_ptr<Script> script_;
 };
 
 }  // namespace vkscript
diff --git a/src/vkscript/parser_test.cc b/src/vkscript/parser_test.cc
index 2a57fe8..1a016af 100644
--- a/src/vkscript/parser_test.cc
+++ b/src/vkscript/parser_test.cc
@@ -102,7 +102,7 @@ TEST_F(VkScriptParserTest, RequireBlockNoArgumentFeatures) {
     ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
     auto script = parser.GetScript();
-    auto& feats = ToVkScript(script.get())->RequiredFeatures();
+    auto& feats = script->RequiredFeatures();
     ASSERT_EQ(1U, feats.size());
     EXPECT_EQ(feature.feature, feats[0]);
   }
diff --git a/src/vkscript/script.cc b/src/vkscript/script.cc
deleted file mode 100644
index c185995..0000000
--- a/src/vkscript/script.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/vkscript/script.h"
-
-#include <utility>
-
-#include "src/make_unique.h"
-
-namespace amber {
-
-const vkscript::Script* ToVkScript(const amber::Script* s) {
-  return static_cast<const vkscript::Script*>(s);
-}
-
-namespace vkscript {
-
-Script::Script() : amber::Script(ScriptType::kVkScript) {}
-
-Script::~Script() = default;
-
-}  // namespace vkscript
-}  // namespace amber
diff --git a/src/vkscript/script.h b/src/vkscript/script.h
deleted file mode 100644
index bf88a6c..0000000
--- a/src/vkscript/script.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_VKSCRIPT_SCRIPT_H_
-#define SRC_VKSCRIPT_SCRIPT_H_
-
-#include <memory>
-#include <vector>
-
-#include "src/buffer.h"
-#include "src/command.h"
-#include "src/make_unique.h"
-#include "src/script.h"
-#include "src/vkscript/section_parser.h"
-
-namespace amber {
-namespace vkscript {
-
-class Script : public amber::Script {
- public:
-  Script();
-  ~Script() override;
-};
-
-}  // namespace vkscript
-
-const vkscript::Script* ToVkScript(const amber::Script* s);
-
-}  // namespace amber
-
-#endif  // SRC_VKSCRIPT_SCRIPT_H_
-- 
cgit v1.2.3