From 943b761b225275539bffc9dc9efe0b2bb2c01aca Mon Sep 17 00:00:00 2001
From: Lee Kerley <ld_kerley@icloud.com>
Date: Tue, 2 Dec 2025 11:48:15 -0800
Subject: [PATCH 1/2] Update OSL Network generator to provide parity with OSL
 Source generator.

This is a pretty large commit, but most of it is all pretty intertwined, so I'll do my best to outline here all the different changes.

### LibsToOso
* The tool now supports selecting using the NodeDef name or the Implementation name as the basis for the name of the new OSL Network generator implementation and corresponding OSO.
* OSL code and corresponding OSO is now generated directly from the NodeDef element.
* `implname` functionality added is used to define the renamed ports.
* NodeGraph elements can now be skipped during processing.

### OSLNetworkGenerator
* Generator now directly inherits from `ShaderGenerator` as there is no common functionality shared with the `OSLShaderGenerator`.
* Provides API to compile OSL source, and also to generate a Shader from a NodeDef element, this is consolidated from the `LibsToOso` tool source.
* The generator can now create a new ShaderNodeImpl object on demand (and the corresponding compiled OSO file) if a locally defined OSL Source Implementation element is discovered. This includes correctly constructing an OSL Source generator object with all the corresponding custom types defined to allow for the correct shader generation to occur.
* `liboslcomp` can be optionally used for the on-demand compilation for better performance, and avoids writing the shader source to disk to compile.
* New `ShaderGraph::flattenGraph()` function is used to correctly expand any locally defined NodeGraph elements in to the corresponding nodes. We do not on-demand compile non-functional NodeGraph elements in to OSOs as they do not have corresponding NodeDef elements to fully name and decorate the interface. Once the `ShaderGraph` is flattened then we are left with a fully expanded graph of individual nodes.
* `OslNetworkSyntax` has been refactored.
  * It no longer has any reserved words, as the grammar used to describe the network has no restrictions on words that are used.
  * Parameter value emitting code has been refactored to better support the "built-in" struct types more cleanly, and removes dependency on the OSL Source syntax, as they are fundamentally two different exports. Including better error handling for types that do not have direct parameter export.

### MaterialXGenShader
* New API method `GenContext::getSourceCodeSearchPath()`, needed to allow dynamic construction of derived generators that share the source code search path.
* New `GenOptions` option `oslTempOsoPath` to allow control over where on-demand OSOs are compiled to. If unspecified the system will fallback to a uniquely generated temp directory in the system temporary directory.
* Support added for `implname` attribute during shader generation. This is described in the specification, but not yet implemented. During OSL source generation when compiling the OSOs its possible input names such as `normal` may be modified to avoid clashes with reserved words. Adding `implname` support allows this to be described in the generated Implementation elements and respected during OSL Network generation. New `getPortName()` function is added in support for the implementation of this feature. This is also needs to be stored in two separate classes, the actual implementation can be either a `ShaderGraph` or a `ShaderNodeImpl`.
* New API method `ShaderGraph::flattenGraph()` will walk the graph and expand any `CompoundNode` entities discovered. Care is taken to generate unique names for newly generated nodes by prefixing the names with the name of the prior parent `CompoundNode`, and also to ensure all connections are retained.
* `ShaderGraph::create()` can now accept and populate the created graph directly from a NodeDef element, which is simpler than the current Node source, as there are no local modifications.
* `Syntax` base class now tracks custom registered syntaxes so they can be easily queried. This is necessary to support dynamic creation of a derived generator, specifically to allow the OSL Network generator to create the OSL Source generator for on-demand compilation of locally defined nodes.

Other supporting changes are outlined below.

### Cmake
* Add CMake option to control if NodeGraph implementations are compiled down to OSOs, or left as NodeGraphs.

### MaterialXFormat
* Add optional `recursive` argument to FilePath::createDirectory(), to allow for recursive directory creation if necessary.
* Add API to FilePath to return the system temporary directory, as well as create a new temporary directory. This is used for on-the-fly compilation of OSL source implementation to OSOs if defined locally in a document and not in a pre-compiled standard library.
* Add a new `createDirectories` option to XmlWriteOptions to allow for any necessary directories to be created while writing a new file.

### MaterialXTest/MaterialXRenderOsl
* Add new test specific implementations for tangent and bitangent nodes for the OSL Network generator. These may become obsolete if the OSL render testing moves to using the OBJ file (see XXXX).
* Update the OSL Network scene template to align the cameras after the OSL Source template was changed.
* Remove the OSL Network specific tests that were skipped - we now have complete one-to-one parity with OSL Source generator.
* Write fully expanded paths in to the template file for easier testing.
* Introduce string processing to the command string that needs to be embedded in a legal XML file to replace illegal XML characters `<` and `>`.
---
 CMakeLists.txt                                |   1 +
 libraries/CMakeLists.txt                      |   7 +-
 resources/Materials/TestSuite/_options.mtlx   |   1 +
 source/MaterialXFormat/File.cpp               |  64 ++-
 source/MaterialXFormat/File.h                 |  18 +-
 source/MaterialXFormat/XmlIo.cpp              |   7 +
 source/MaterialXFormat/XmlIo.h                |   4 +
 source/MaterialXGenOsl/CMakeLists.txt         |  14 +
 source/MaterialXGenOsl/LibsToOso.cpp          | 278 +++-------
 source/MaterialXGenOsl/Nodes/OsoNode.cpp      |  17 +-
 source/MaterialXGenOsl/Nodes/OsoNode.h        |   5 +
 .../OslNetworkShaderGenerator.cpp             | 335 ++++++++++--
 .../OslNetworkShaderGenerator.h               |  51 +-
 source/MaterialXGenOsl/OslNetworkSyntax.cpp   | 488 ++++++++----------
 source/MaterialXGenOsl/OslNetworkSyntax.h     |  40 +-
 source/MaterialXGenOsl/OslShaderGenerator.cpp |  25 +-
 source/MaterialXGenOsl/OslShaderGenerator.h   |  16 +-
 source/MaterialXGenShader/GenContext.h        |   7 +
 source/MaterialXGenShader/GenOptions.h        |   6 +-
 source/MaterialXGenShader/ShaderGenerator.cpp |   4 +-
 source/MaterialXGenShader/ShaderGenerator.h   |  23 +
 source/MaterialXGenShader/ShaderGraph.cpp     | 285 +++++++++-
 source/MaterialXGenShader/ShaderGraph.h       |  20 +
 source/MaterialXGenShader/ShaderNode.cpp      |  17 +
 source/MaterialXGenShader/ShaderNode.h        |   9 +
 source/MaterialXGenShader/ShaderNodeImpl.cpp  |  11 +
 source/MaterialXGenShader/ShaderNodeImpl.h    |   6 +
 source/MaterialXGenShader/Syntax.cpp          |   6 +-
 source/MaterialXGenShader/Syntax.h            |   6 +-
 .../MaterialXRenderOsl/RenderOsl.cpp          |  67 ++-
 ...M_bitangent_vector3_genoslnetwork_test.osl |   9 +
 .../IM_tangent_vector3_genoslnetwork_test.osl |   9 +
 .../Utilities/scene_template_oslcmd.xml       |   5 +-
 33 files changed, 1296 insertions(+), 565 deletions(-)
 create mode 100644 source/MaterialXTest/MaterialXRenderOsl/Utilities/IM_bitangent_vector3_genoslnetwork_test.osl
 create mode 100644 source/MaterialXTest/MaterialXRenderOsl/Utilities/IM_tangent_vector3_genoslnetwork_test.osl

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 06f720ad3b..56f93e2cf2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -51,6 +51,7 @@ option(MATERIALX_BUILD_OCIO "Build OpenColorIO support for shader generators." O
 option(MATERIALX_BUILD_TESTS "Build unit tests." OFF)
 option(MATERIALX_BUILD_BENCHMARK_TESTS "Build benchmark tests." OFF)
 option(MATERIALX_BUILD_OSOS "Build OSL .oso's of standard library shaders for the OSL Network generator" OFF)
+option(MATERIALX_BUILD_NODEGRAPH_OSOS "Build NodeGraphs as OSOs, if disabled then NodeGraphs are not compiled as OSOs " OFF)
 
 option(MATERIALX_BUILD_SHARED_LIBS "Build MaterialX libraries as shared rather than static." OFF)
 option(MATERIALX_BUILD_DATA_LIBRARY "Build generated products from the MaterialX data library." OFF)
diff --git a/libraries/CMakeLists.txt b/libraries/CMakeLists.txt
index 432df18bea..5015cfd564 100644
--- a/libraries/CMakeLists.txt
+++ b/libraries/CMakeLists.txt
@@ -35,6 +35,11 @@ if(MATERIALX_BUILD_DATA_LIBRARY)
 
         set(SENTINEL_FILE ${CMAKE_CURRENT_BINARY_DIR}/buildosos.sentinel)
 
+        set(SKIP_BUILDING_NODEGRAPHS "")
+        if (NOT MATERIALX_BUILD_NODEGRAPH_OSOS)
+            set(SKIP_BUILDING_NODEGRAPHS "--skipConvertingNodegraphs")
+        endif()
+
         add_custom_command(
                 OUTPUT ${SENTINEL_FILE}
                 COMMAND touch ${SENTINEL_FILE}
@@ -46,7 +51,7 @@ if(MATERIALX_BUILD_DATA_LIBRARY)
                             --oslCompilerPath ${MATERIALX_OSL_BINARY_OSLC}
                             --oslIncludePath ${MATERIALX_OSL_INCLUDE_PATH}
                             --libraryRelativeOsoPath libraries/targets/genoslnetwork/osos
-                            --removeNdPrefix true
+                            ${SKIP_BUILDING_NODEGRAPHS}
                 DEPENDS ${MATERIALX_DATA_LIBRARY_SOURCE_FILES} MaterialXGenOsl_LibsToOso
         )
 
diff --git a/resources/Materials/TestSuite/_options.mtlx b/resources/Materials/TestSuite/_options.mtlx
index a5d0623f2d..2fb5673e52 100644
--- a/resources/Materials/TestSuite/_options.mtlx
+++ b/resources/Materials/TestSuite/_options.mtlx
@@ -63,6 +63,7 @@
 
     <!-- List of document paths for render tests -->
     <input name="renderTestPaths" type="string" value="resources/Materials/Examples/StandardSurface,resources/Materials/TestSuite/stdlib/convolution,resources/Materials/TestSuite/stdlib/color_management,resources/Materials/TestSuite/stdlib/procedural,resources/Materials/TestSuite/pbrlib/surfaceshader,resources/Materials/TestSuite/nprlib,resources/Materials/TestSuite/pbrlib/bsdf" />
+<!--    <input name="renderTestPaths" type="string" value="resources/Materials/Examples,resources/Materials/TestSuite" />-->
 
     <!-- Enable reference quality rendering.
          This option enables higher sample counts and supersampling in render tests,
diff --git a/source/MaterialXFormat/File.cpp b/source/MaterialXFormat/File.cpp
index f101844de7..c4570c4f79 100644
--- a/source/MaterialXFormat/File.cpp
+++ b/source/MaterialXFormat/File.cpp
@@ -30,7 +30,9 @@
 #include <array>
 #include <cctype>
 #include <cerrno>
-#include <cstring>
+// #include <cstring>
+#include <random>
+#include <filesystem>
 
 MATERIALX_NAMESPACE_BEGIN
 
@@ -278,8 +280,12 @@ FilePathVec FilePath::getSubDirectories() const
     return dirs;
 }
 
-void FilePath::createDirectory() const
+void FilePath::createDirectory(bool recursive) const
 {
+    if (recursive && !getParentPath().isDirectory())
+    {
+        getParentPath().createDirectory(recursive);
+    }
 #if defined(_WIN32)
     _mkdir(asString().c_str());
 #else
@@ -377,4 +383,58 @@ FileSearchPath getEnvironmentPath(const string& sep)
     return FileSearchPath(searchPathEnv, sep);
 }
 
+FilePath FilePath::createTemporaryDirectory(const FilePath& parentDir)
+{
+    // Get the parent directory - use system temp if empty
+    FilePath tempParent = parentDir;
+    if (tempParent.isEmpty())
+    {
+        tempParent = getSystemTemporaryDirectory();
+    }
+
+    // Ensure parent directory exists
+    if (!tempParent.exists())
+    {
+        tempParent.createDirectory(true);
+    }
+
+    if (!tempParent.isDirectory())
+    {
+        throw Exception("Parent path is not a directory: " + tempParent.asString());
+    }
+
+    // Generate a unique temporary directory name using std::filesystem
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<> dis(100000, 999999);
+
+    constexpr int maxAttempts = 1000;
+    for (int attempt = 0; attempt < maxAttempts; ++attempt)
+    {
+        string tempDirName = "materialx_tmp_" + std::to_string(dis(gen));
+        FilePath tempDirPath = tempParent / tempDirName;
+
+        if (!tempDirPath.isDirectory())
+        {
+            tempDirPath.createDirectory(true);
+            return tempDirPath;
+        }
+    }
+
+    throw Exception("Failed to create temporary directory after " + std::to_string(maxAttempts) + " attempts");
+}
+
+FilePath FilePath::getSystemTemporaryDirectory()
+{
+    try
+    {
+        std::filesystem::path tempPath = std::filesystem::temp_directory_path();
+        return FilePath(tempPath.string());
+    }
+    catch (const std::filesystem::filesystem_error& ex)
+    {
+        throw Exception("Error getting system temporary directory: " + string(ex.what()));
+    }
+}
+
 MATERIALX_NAMESPACE_END
diff --git a/source/MaterialXFormat/File.h b/source/MaterialXFormat/File.h
index 33c4ddada2..40665ca2b5 100644
--- a/source/MaterialXFormat/File.h
+++ b/source/MaterialXFormat/File.h
@@ -195,7 +195,11 @@ class MX_FORMAT_API FilePath
     FilePathVec getSubDirectories() const;
 
     /// Create a directory on the file system at the given path.
-    void createDirectory() const;
+    /// @param recursive If true, creates parent directories as needed.
+    ///    If false (default), only creates the final directory.
+    /// @note Succeeds silently if directory already exists. Does not return
+    ///    error status - use exists() or isDirectory() to verify success.
+    void createDirectory(bool recursive=false) const;
 
     /// Set the current working directory of the file system.
     bool setCurrentPath();
@@ -208,6 +212,18 @@ class MX_FORMAT_API FilePath
     /// Return the directory containing the executable module.
     static FilePath getModulePath();
 
+    /// Create a temporary directory with a unique name.
+    /// @param parentDir The parent directory for the temporary directory.
+    ///    If empty, uses the system's default temporary directory.
+    /// @return A FilePath to the created temporary directory.
+    /// @throws Exception if the temporary directory cannot be created.
+    static FilePath createTemporaryDirectory(const FilePath& parentDir = FilePath());
+
+    /// Return the system's default temporary directory.
+    /// @return A FilePath to the system temporary directory.
+    /// @throws Exception if the system temporary directory cannot be determined.
+    static FilePath getSystemTemporaryDirectory();
+
   private:
     StringVec _vec;
     Type _type;
diff --git a/source/MaterialXFormat/XmlIo.cpp b/source/MaterialXFormat/XmlIo.cpp
index 83e4721dc1..d06a77ed1c 100644
--- a/source/MaterialXFormat/XmlIo.cpp
+++ b/source/MaterialXFormat/XmlIo.cpp
@@ -355,6 +355,13 @@ void writeToXmlStream(DocumentPtr doc, std::ostream& stream, const XmlWriteOptio
 
 void writeToXmlFile(DocumentPtr doc, const FilePath& filename, const XmlWriteOptions* writeOptions)
 {
+    if (writeOptions && writeOptions->createDirectories)
+    {
+        if (!filename.getParentPath().isDirectory())
+        {
+            filename.getParentPath().createDirectory(true);
+        }
+    }
     std::ofstream ofs(filename.asString());
     writeToXmlStream(doc, ofs, writeOptions);
 }
diff --git a/source/MaterialXFormat/XmlIo.h b/source/MaterialXFormat/XmlIo.h
index 5c80ae8005..59126a0032 100644
--- a/source/MaterialXFormat/XmlIo.h
+++ b/source/MaterialXFormat/XmlIo.h
@@ -73,6 +73,10 @@ class MX_FORMAT_API XmlWriteOptions
     /// If provided, this function will be used to exclude specific elements
     /// (those returning false) from the write operation.  Defaults to nullptr.
     ElementPredicate elementPredicate;
+
+    /// If true, any necessary directories will be created to write the
+    /// file.
+    bool createDirectories = false;
 };
 
 /// @class ExceptionParseError
diff --git a/source/MaterialXGenOsl/CMakeLists.txt b/source/MaterialXGenOsl/CMakeLists.txt
index 6d09739060..28dbc56926 100644
--- a/source/MaterialXGenOsl/CMakeLists.txt
+++ b/source/MaterialXGenOsl/CMakeLists.txt
@@ -14,6 +14,20 @@ mx_add_library(MaterialXGenOsl
     EXPORT_DEFINE
         MATERIALX_GENOSL_EXPORTS)
 
+if (OSL_FOUND)
+    target_link_libraries(${TARGET_NAME}
+            PRIVATE
+            OSL::oslcomp)
+    target_compile_definitions(${TARGET_NAME}
+            PRIVATE
+            USE_OSLCOMP)
+endif()
+
+target_compile_definitions(${TARGET_NAME} PRIVATE
+        MATERIALX_OSL_BINARY_OSLC=\"${MATERIALX_OSL_BINARY_OSLC}\"
+        MATERIALX_OSL_INCLUDE_PATH=\"${MATERIALX_OSL_INCLUDE_PATH}\"
+)
+
 if (MATERIALX_BUILD_OSOS)
     file(GLOB GenNodes_SRC "${CMAKE_CURRENT_SOURCE_DIR}/LibsToOso.cpp")
 
diff --git a/source/MaterialXGenOsl/LibsToOso.cpp b/source/MaterialXGenOsl/LibsToOso.cpp
index aca0e7c6ca..ba0a9d015a 100644
--- a/source/MaterialXGenOsl/LibsToOso.cpp
+++ b/source/MaterialXGenOsl/LibsToOso.cpp
@@ -16,7 +16,7 @@
 #include <MaterialXGenShader/Shader.h>
 
 #include <MaterialXGenOsl/OslShaderGenerator.h>
-#include <MaterialXGenOsl/OslSyntax.h>
+#include <MaterialXGenOsl/OslNetworkShaderGenerator.h>
 
 #ifdef USE_OSLCOMP
 #include <OSL/oslcomp.h>
@@ -26,162 +26,57 @@ namespace mx = MaterialX;
 
 const std::string argOptions =
     " Options: \n"
-    "    --outputOsoPath [DIRPATH]       TODO\n"
-    "    --libraryRelativeOsoPath [DIRPATH]       TODO\n"
-    "    --outputMtlxPath [DIRPATH]      TODO\n"
-    "    --oslCompilerPath [FILEPATH]    TODO\n"
+    "    --outputOsoPath [DIRPATH]            Directory where compiled OSO files will be written\n"
+    "    --libraryRelativeOsoPath [DIRPATH]   Relative path used in MaterialX implementation elements to reference OSO files\n"
+    "    --outputMtlxPath [DIRPATH]           Directory where MaterialX implementation documents will be written\n"
+    "    --oslCompilerPath [FILEPATH]         Path to the OSL compiler executable (oslc)\n"
 #ifdef USE_OSLCOMP
-    "    --useOslC                       TODO\n"
+    "    --useOslC                            Use external OSL compiler instead of liboslcomp (when available)\n"
 #endif
-    "    --skipWritingOSLSource          TODO\n"
-    "    --skipWritingMtlxDoc            TODO\n"
-    "    --oslIncludePath [DIRPATH]      TODO\n"
-    "    --path [FILEPATH]              Specify an additional data search path location (e.g. '/projects/MaterialX').  This absolute path will be queried when locating data libraries, XInclude references, and referenced images.\n"
-    "    --library [FILEPATH]           Specify an additional data library folder (e.g. 'vendorlib', 'studiolib').  This relative path will be appended to each location in the data search path when loading data libraries.\n"
-    "    --osoNameStrategy [STRING]      TODO - either 'implementation' or 'nodedef' (default:'implementation')\n"
-    "    --help                          Display the complete list of command-line options\n";
-
-class ExceptionCompileError : public mx::Exception
-{
-public:
-    ExceptionCompileError(const std::string& msg, const mx::StringVec& errorLog = mx::StringVec()) :
-        Exception(msg),
-        _errorLog(errorLog)
-    {
-    }
-
-    ExceptionCompileError(const ExceptionCompileError& e) :
-        Exception(e),
-        _errorLog(e._errorLog)
-    {
-    }
-
-    ExceptionCompileError& operator=(const ExceptionCompileError& e)
-    {
-        Exception::operator=(e);
-        _errorLog = e._errorLog;
-        return *this;
-    }
+    "    --skipWritingOSLSource               Skip writing OSL source files to disk during compilation\n"
+    "    --skipWritingMtlxDoc                 Skip writing MaterialX implementation documents\n"
+    "    --skipConvertingNodegraphs           Skip converting nodegraph implementations to OSL shaders\n"
+    "    --oslIncludePath [DIRPATH]           Directory containing OSL include files\n"
+    "    --path [FILEPATH]                    Specify an additional data search path location (e.g. '/projects/MaterialX').  This absolute path will be queried when locating data libraries, XInclude references, and referenced images.\n"
+    "    --library [FILEPATH]                 Specify an additional data library folder (e.g. 'vendorlib', 'studiolib').  This relative path will be appended to each location in the data search path when loading data libraries.\n"
+    "    --osoNameStrategy [STRING]           Naming strategy for OSO files - either 'implementation' or 'nodedef' (default:'implementation')\n"
+    "    --help                               Display the complete list of command-line options\n";
 
-    const mx::StringVec& errorLog() const
-    {
-        return _errorLog;
-    }
-
-private:
-    mx::StringVec _errorLog;
-};
 
-// A set of options for controlling the behavior of OSL compilation.
-class OslCompileOptions
+void createMtlxImplementationElementForOsoNode(mx::ConstNodeDefPtr nodeDef, mx::ShaderPtr oslShader, const std::string& oslShaderName, mx::DocumentPtr mtlxDoc, const std::string& osoPath)
 {
-public:
-    OslCompileOptions() = default;
-    ~OslCompileOptions() = default;
-
-    mx::FilePath oslCompilerPath;
-    mx::FileSearchPath oslIncludePath;
-    bool useOslComp = false;
-    bool writeSourceToDisk = true;
-};
-
-bool compileOSL(const std::string& oslSourceCode, const mx::FilePath& oslFilePath, const OslCompileOptions& options)
-{
-    if (!options.useOslComp && !options.writeSourceToDisk)
-    {
-        throw mx::Exception("If OslComp library is not being used the source must be written to disk");
-    }
-
-    if (options.writeSourceToDisk)
+    mx::ImplementationPtr impl = mtlxDoc->addImplementation(oslShaderName);
+    impl->setNodeDef(nodeDef);
+    impl->setFile(osoPath);
+
+    impl->setFunction(oslShaderName);
+    impl->setAttribute("sourcecode", "dummy");
+    impl->setTarget(mx::OslNetworkShaderGenerator::TARGET);
+
+    // Compare the shader input names in the source (variable)
+    // with the names of the corresponding port.
+    // If there is a difference then we use the "implname"
+    // attribute to record that difference so that the OSLNetwork generator
+    // can use it.
+    mx::ShaderGraph& graph = oslShader->getGraph();
+    for (mx::ShaderGraphInputSocket* inputSocket : graph.getInputSockets())
     {
-        std::ofstream oslFile;
-        oslFile.open(oslFilePath);
-        oslFile << oslSourceCode;
-        oslFile.close();
-    }
-
-    mx::FilePath osoFilePath = oslFilePath;
-    osoFilePath.removeExtension();
-    osoFilePath.addExtension("oso");
+        std::string name = inputSocket->getName();
+        std::string variable = inputSocket->getVariable();
 
-    // build up a vector of compiler arguments that will be
-    // used in both compiler modes.
-    std::vector<std::string> oslCompilerArgs;
-    oslCompilerArgs.emplace_back("-o");
-    oslCompilerArgs.emplace_back(osoFilePath);
-    for (mx::FilePath p : options.oslIncludePath)
-    {
-        oslCompilerArgs.emplace_back("-I" + p.asString() + "");
-    }
-
-#ifdef USE_OSLCOMP
-    if (options.useOslComp)
-    {
-        // Use OSL::oslcomp to compile the shader - this is significantly faster than using the system
-        // call to involke the `oslc` command line tool
-        OIIO::ErrorHandler errorHandler;
-        ::OSL::OSLCompiler compiler(&errorHandler);
-        if (options.writeSourceToDisk)
-        {
-            // Compile from the source file
-            compiler.compile(oslFilePath.asString(), oslCompilerArgs);
-        }
-        else
-        {
-            // Compile directly from the string buffer
-            std::string osoBuffer;
-            compiler.compile_buffer(oslSourceCode, osoBuffer, oslCompilerArgs, std::string_view(), oslFilePath.asString());
-
-            std::ofstream osoFile;
-            osoFile.open(osoFilePath.asString());
-            osoFile << osoBuffer;
-            osoFile.close();
-        }
-    }
-    else
-#endif
-    {
-        // If no command and include path specified then skip checking.
-        if (options.oslCompilerPath.isEmpty())
-        {
-            throw mx::Exception("OSL compiler path missing");
-        }
-        if (!options.oslCompilerPath.exists())
+        if (inputSocket->getType() == mx::Type::FILENAME)
         {
-            throw mx::Exception("OSL compiler doesn't exist at '" + options.oslCompilerPath.asString() + "'");
+            // We suffix the inputs of type FILENAME with "_resource" so we need to
+            // remove that here for the implName comparison
+            variable = std::string(variable, 0, variable.size() - std::string("_resource").size());
         }
 
-        // Use a known error file name to check
-        std::string errorFile(osoFilePath.asString() + "_compile_errors.txt");
-        const std::string redirectString(" 2>&1");
-
-        // Run the command and get back the result. If non-empty string throw exception with error
-        std::string command = options.oslCompilerPath.asString() + " -q " + oslFilePath.asString();
-        for (const auto& arg : oslCompilerArgs)
+        if (name != variable)
         {
-            command += " " + arg;
-        }
-        // command += " > " + errorFile + redirectString;
-
-        int returnValue = std::system(command.c_str());
-
-        std::ifstream errorStream(errorFile);
-        std::string result;
-        result.assign(std::istreambuf_iterator<char>(errorStream),
-                      std::istreambuf_iterator<char>());
-
-        if (!result.empty())
-        {
-            mx::StringVec errors;
-            errors.push_back("Command string: " + command);
-            errors.push_back("Command return code: " + std::to_string(returnValue));
-            errors.push_back("Shader failed to compile:");
-            errors.push_back(result);
-            throw ExceptionCompileError("OSL compilation error", errors);
+            mx::InputPtr implInput = impl->addInput(name, inputSocket->getType().getName());
+            implInput->setImplementationName(variable);
         }
     }
-
-    return true;
 }
 
 int main(int argc, char* const argv[])
@@ -204,6 +99,7 @@ int main(int argc, char* const argv[])
     std::string argOsoNameStrategy = "implementation";
     bool argSkipWritingSource = false;
     bool argSkipWritingMtlxDoc = false;
+    bool argSkipConvertingNodegraphs = false;
     bool argUseOslC = false;
 
     // Loop over the provided arguments, and store their associated values.
@@ -252,6 +148,10 @@ int main(int argc, char* const argv[])
         {
             argSkipWritingMtlxDoc = true;
         }
+        else if (token == "--skipConvertingNodegraphs")
+        {
+            argSkipConvertingNodegraphs = true;
+        }
         else if (token == "--useOslC")
         {
             argUseOslC = true;
@@ -277,9 +177,7 @@ int main(int argc, char* const argv[])
             continue;
         }
 
-        if (nextToken.empty())
-            std::cout << "Expected another token following command-line option: " << token << std::endl;
-        else
+        if (!nextToken.empty())
             i++;
     }
 
@@ -296,7 +194,7 @@ int main(int argc, char* const argv[])
     mx::FilePath outputOsoPath(argOutputOsoPath);
     if (!outputOsoPath.exists() || !outputOsoPath.isDirectory())
     {
-        outputOsoPath.createDirectory();
+        outputOsoPath.createDirectory(true);
 
         if (!outputOsoPath.exists() || !outputOsoPath.isDirectory())
         {
@@ -366,7 +264,7 @@ int main(int argc, char* const argv[])
     oslRendererIncludePaths.append(argSearchPath.find("libraries/stdlib/genosl/include"));
 
     // Create the OSL shader generator.
-    mx::ShaderGeneratorPtr oslShaderGen = mx::OslShaderGenerator::create();
+    mx::OslShaderGeneratorPtr oslShaderGen = std::static_pointer_cast<mx::OslShaderGenerator>(mx::OslShaderGenerator::create());
 
     // Register types from the libraries on the OSL shader generator.
     oslShaderGen->registerTypeDefs(librariesDoc);
@@ -379,7 +277,7 @@ int main(int argc, char* const argv[])
     context.getOptions().fileTextureVerticalFlip = false;
     context.getOptions().oslImplicitSurfaceShaderConversion = false;
 
-    OslCompileOptions options;
+    mx::OslNetworkShaderGenerator::OslCompileOptions options;
     options.oslIncludePath = oslRendererIncludePaths;
     options.writeSourceToDisk = !argSkipWritingSource;
     options.oslCompilerPath = argOslCompilerPath;
@@ -390,11 +288,8 @@ int main(int argc, char* const argv[])
     // We'll use this boolean to return an error code is one of the `NodeDef` failed to codegen/compile.
     bool hasFailed = false;
 
-    // We create and use a dedicated `NodeGraph` to avoid `NodeDef` names collision.
-    mx::NodeGraphPtr librariesDocGraph = librariesDoc->addNodeGraph("librariesDocGraph");
-
     // Loop over all the `NodeDef` gathered in our documents from the provided libraries.
-    for (mx::NodeDefPtr nodeDef : librariesDoc->getNodeDefs())
+    for (mx::ConstNodeDefPtr nodeDef : librariesDoc->getNodeDefs())
     {
         // Determine whether or not there's a valid implementation of the current `NodeDef` for the type associated
         // to our OSL shader generator, i.e. OSL, and if not, skip it.
@@ -405,53 +300,25 @@ int main(int argc, char* const argv[])
             std::cout << "The following `NodeDef` does not provide a valid OSL implementation, "
                          "and will be skipped: "
                       << nodeDef->getName() << std::endl;
-
             continue;
         }
 
-        // Intention is here is to name the new node the same as the genosl implementation name
-        // but replacing "_genosl" with "_genoslnetwork"
-        std::string nodeName;
-        if (argOsoNameStrategy == "implementation")
-        {
-            // Name the node the same as the implementation with _genoslnetwork added as a suffix.
-            // NOTE : If the implementation currently has _genosl as a suffix then we remove it.
-            nodeName = nodeImpl->getName();
-            nodeName = mx::replaceSubstrings(nodeName, { { "_genosl", "" } });
-            nodeName += "_genoslnetwork";
-        }
-        else
-        {
-            // Name the node the same as the node definition
-            nodeName = nodeDef->getName();
-        }
-
-        mx::NodePtr node = librariesDocGraph->addNodeInstance(nodeDef, nodeName);
-        if (!node)
+        if (argSkipConvertingNodegraphs)
         {
-            std::cerr << "Unable to create Node instance for NodeDef - '" << nodeDef->getName() << "'" << std::endl;
-            return 1;
+            // If we've been asked to skip converting nodegraphs - then we need to check
+            // what type of implementation we've been given.
+            if (nodeImpl->isA<mx::NodeGraph>())
+            {
+                std::cout << "Skipping " << nodeDef->getName() << " - NodeGraph implementation" << std::endl;
+                continue;
+            }
         }
 
-        std::string oslShaderName = node->getName();
-        oslShaderGen->getSyntax().makeValidName(oslShaderName);
-
-        const std::string oslFileName = oslShaderName + ".osl";
-        const std::string& oslFilePath = (outputOsoPath / oslFileName).asString();
-        std::ofstream oslFile;
-
-        // Codegen the `Node` to an `.osl` file.
         mx::ShaderPtr oslShader = nullptr;
         try
         {
             // Codegen the `Node` to OSL.
-            oslShader = oslShaderGen->generate(node->getName(), node, context);
-
-            // TODO: Check that we have a valid/opened file descriptor before doing anything with it?
-            oslFile.open(oslFilePath);
-            // Dump the content of the codegen'd `NodeDef` to our `.osl` file.
-            oslFile << oslShader->getSourceCode();
-            oslFile.close();
+            oslShader =  mx::OslNetworkShaderGenerator::generateOSLShader(nodeDef, oslShaderGen, context, argOsoNameStrategy);
         }
         // Catch any codegen/compilation related exceptions.
         catch (mx::ExceptionShaderGenError& exc)
@@ -460,31 +327,30 @@ int main(int argc, char* const argv[])
                          "following node: "
                       << nodeDef->getName() << std::endl;
             std::cerr << exc.what() << std::endl;
+        }
 
+        if (!oslShader)
+        {
+            std::cerr << "Failed to generate shader for the "
+                         "following node: "
+                      << nodeDef->getName() << std::endl;
             hasFailed = true;
         }
 
-        // Compile the codegen'd `.osl` file.
+        const std::string oslFileName = oslShader->getName() + ".osl";
+        const std::string& oslFilePath = (outputOsoPath / oslFileName).asString();
+        std::ofstream oslFile;
+
         try
         {
             // Compile the `.osl` file to a `.oso` file next to it.
-            compileOSL(oslShader->getSourceCode(), oslFilePath, options);
+            mx::OslNetworkShaderGenerator::compileOSL(oslShader->getSourceCode(), oslFilePath, options);
 
-            {
-                std::string implName = "IMPL_" + nodeName + "_" + target;
-                auto impl = implMtlxDoc->addImplementation(implName);
-                impl->setNodeDef(nodeDef);
-                // TODO: stash the the OSO path here.
-                // This is writing the absolute path - which we don't want
-                impl->setFile(argLibraryRelativeOsoPath);
-
-                impl->setFunction(oslShaderName);
-                impl->setAttribute("sourcecode", "dummy");
-                impl->setTarget(target);
-            }
+            // Create the MaterialX Implementation element
+            createMtlxImplementationElementForOsoNode(nodeDef, oslShader, oslShader->getName(), implMtlxDoc, argLibraryRelativeOsoPath);
         }
         // Catch any codegen/compilation related exceptions.
-        catch (ExceptionCompileError& exc)
+        catch (mx::ExceptionOslCompileError& exc)
         {
             std::cerr << "Encountered a shader compilation related exception for the "
                          "following node: "
diff --git a/source/MaterialXGenOsl/Nodes/OsoNode.cpp b/source/MaterialXGenOsl/Nodes/OsoNode.cpp
index 38db62be63..f299539f90 100644
--- a/source/MaterialXGenOsl/Nodes/OsoNode.cpp
+++ b/source/MaterialXGenOsl/Nodes/OsoNode.cpp
@@ -13,6 +13,11 @@ ShaderNodeImplPtr OsoNode::create()
     return std::make_shared<OsoNode>();
 }
 
+ShaderNodeImplPtr OsoNode::create(const string& osoName, const string& osoPath)
+{
+    return std::make_shared<OsoNode>(osoName, osoPath);
+}
+
 void OsoNode::initialize(const InterfaceElement& element, GenContext& context)
 {
     ShaderNodeImpl::initialize(element, context);
@@ -23,9 +28,15 @@ void OsoNode::initialize(const InterfaceElement& element, GenContext& context)
     }
     const Implementation& impl = static_cast<const Implementation&>(element);
 
-    // Implementation's function attr is the oso filename, file attr is its directory
-    _osoName = impl.getFunction();
-    _osoPath = impl.getFile();
+    // We guard setting up the node to allow statically created nodes to be registered.
+    // We use this in the unit testing for OslNetwork generator for handling the modified
+    // bitangent and tangent nodes.
+    if (_osoName.empty())
+    {
+        // Implementation's function attr is the oso filename, file attr is its directory
+        _osoName = impl.getFunction();
+        _osoPath = impl.getFile();
+    }
 
     // Set hash using the oso name.
     _hash = std::hash<string>{}(_osoName);
diff --git a/source/MaterialXGenOsl/Nodes/OsoNode.h b/source/MaterialXGenOsl/Nodes/OsoNode.h
index 100becc569..17d255aeff 100644
--- a/source/MaterialXGenOsl/Nodes/OsoNode.h
+++ b/source/MaterialXGenOsl/Nodes/OsoNode.h
@@ -15,7 +15,12 @@ MATERIALX_NAMESPACE_BEGIN
 class MX_GENOSL_API OsoNode : public ShaderNodeImpl
 {
 public:
+    OsoNode() {}
+    OsoNode(const string& osoName, const string& osoPath) :
+        _osoName(osoName), _osoPath(osoPath) {}
+
     static ShaderNodeImplPtr create();
+    static ShaderNodeImplPtr create(const string& osoName, const string& osoPath);
 
     void initialize(const InterfaceElement& element, GenContext& context) override;
 
diff --git a/source/MaterialXGenOsl/OslNetworkShaderGenerator.cpp b/source/MaterialXGenOsl/OslNetworkShaderGenerator.cpp
index 4c33ae142e..5cfedda2f5 100644
--- a/source/MaterialXGenOsl/OslNetworkShaderGenerator.cpp
+++ b/source/MaterialXGenOsl/OslNetworkShaderGenerator.cpp
@@ -6,24 +6,129 @@
 #include <MaterialXGenOsl/OslNetworkShaderGenerator.h>
 #include <MaterialXGenOsl/OslNetworkSyntax.h>
 #include <MaterialXGenOsl/Nodes/OsoNode.h>
+#include <MaterialXGenOsl/OslShaderGenerator.h>
+#include <MaterialXGenOsl/OslSyntax.h>
 
 #include <MaterialXGenShader/GenContext.h>
 #include <MaterialXGenShader/Shader.h>
 #include <MaterialXGenShader/TypeDesc.h>
 #include <MaterialXGenShader/ShaderStage.h>
+#include <MaterialXGenShader/ShaderGraph.h>
+
+#include <MaterialXCore/Document.h>
+
+#ifdef USE_OSLCOMP
+    #include <OSL/oslcomp.h>
+#endif
+
+#include <iostream>
+#include <fstream>
 
 MATERIALX_NAMESPACE_BEGIN
 
+class OslNetworkStructTypeSyntax;
+using OslNetworkStructTypeSyntaxPtr = shared_ptr<OslNetworkStructTypeSyntax>;
+
 const string OslNetworkShaderGenerator::TARGET = "genoslnetwork";
 
+namespace
+{
+
+ShaderNodeImplPtr createNewImplementation(const NodeDef& nodedef, TypeSystemPtr typeSystem, const Syntax& syntax, GenContext& context)
+{
+    OslSyntaxPtr oslSyntax = std::static_pointer_cast<OslSyntax>(OslSyntax::create(typeSystem));
+
+    // we need to populate the OslSyntax with the any custom syntaxes present in the OslNetworkSyntax
+    for (const auto& [typeDesc, syntaxPtr] : syntax.getCustomTypeSyntaxes())
+    {
+        OslNetworkStructTypeSyntaxPtr structSyntax = std::dynamic_pointer_cast<OslNetworkStructTypeSyntax>(syntaxPtr);
+        if (!structSyntax)
+            continue;
+
+        StructTypeSyntaxPtr newStructSyntax = oslSyntax->createStructSyntax(structSyntax->getName(),
+                                                                            structSyntax->getDefaultValue(false),
+                                                                            structSyntax->getDefaultValue(true),
+                                                                            structSyntax->getTypeAlias(),
+                                                                            structSyntax->getTypeDefinition());
+        oslSyntax->registerTypeSyntax(typeDesc, newStructSyntax, true);
+    }
+
+    // Context already has the source code search path
+    const FileSearchPath& sourceCodeSearchPath = context.getSourceCodeSearchPath();
+
+    OslShaderGeneratorPtr oslShaderGen = std::static_pointer_cast<OslShaderGenerator>(OslShaderGenerator::create(typeSystem, oslSyntax));
+
+    // Create a new temporary GenContext to avoid clashing with the parent context
+    GenContext localContext(oslShaderGen);
+    localContext.registerSourceCodeSearchPath(sourceCodeSearchPath);
+    localContext.getOptions() = context.getOptions();
+    localContext.getOptions().oslImplicitSurfaceShaderConversion = false;
+    localContext.getOptions().oslConnectCiWrapper = false;
+
+    ConstNodeDefPtr nodeDefPtr = std::static_pointer_cast<const NodeDef>(nodedef.getSelf());
+
+    ShaderPtr oslShader = OslNetworkShaderGenerator::generateOSLShader(nodeDefPtr, oslShaderGen, localContext);
+    if (!oslShader)
+    {
+        throw ExceptionShaderGenError("Failed to generate OSL Shader for '" + nodedef.getName() + "'");
+        return nullptr;
+    }
+
+    OslNetworkShaderGenerator::OslCompileOptions options;
+    options.oslIncludePath = sourceCodeSearchPath;
+    FilePath oslStdIncludePath = FilePath(MATERIALX_OSL_INCLUDE_PATH);
+    if (oslStdIncludePath.exists())
+    {
+        options.oslIncludePath.append(oslStdIncludePath);
+    }
+#ifdef USE_OSLCOMP
+    options.writeSourceToDisk = true;
+    options.useOslComp = true;
+#else
+    options.writeSourceToDisk = false;
+    FilePath oslCompilerPath = FilePath(MATERIALX_OSL_BINARY_OSLC);
+    if (!oslCompilerPath.exists())
+    {
+        throw ExceptionShaderGenError("Dynamic OslNode generation not supported if oslc not provided");
+    }
+    options.oslCompilerPath = oslCompilerPath;
+#endif
+
+    FilePath osoPath = context.getOptions().oslTempOsoPath;
+    if (osoPath.isEmpty())
+    {
+        osoPath = FilePath::createTemporaryDirectory();
+    }
+
+    FilePath oslFilePath = osoPath / FilePath(oslShader->getName() + ".osl");
+
+    OslNetworkShaderGenerator::compileOSL(oslShader->getSourceCode(), oslFilePath, options);
+
+    ShaderNodeImplPtr osoNodeImpl = OsoNode::create(oslShader->getName(), osoPath.asString());
+
+    addPortImplementationNames(nodedef.getImplementation(OslShaderGenerator::TARGET), *osoNodeImpl);
+
+    return osoNodeImpl;
+}
+
+} // namespace
+
 //
 // OslNetworkShaderGenerator methods
 //
 
 OslNetworkShaderGenerator::OslNetworkShaderGenerator(TypeSystemPtr typeSystem) :
-    OslShaderGenerator(typeSystem)
+    ShaderGenerator(typeSystem, OslNetworkSyntax::create(typeSystem))
 {
-    _syntax = OslNetworkSyntax::create(typeSystem);
+}
+
+ShaderNodeImplPtr OslNetworkShaderGenerator::getImplementation(const NodeDef& nodedef, GenContext& context) const
+{
+    ShaderNodeImplPtr nodeImpl = ShaderGenerator::getImplementation(nodedef, context);
+    if (nodeImpl)
+        return nodeImpl;
+
+    return createNewImplementation(nodedef, getTypeSystem(), getSyntax(), context);
 }
 
 ShaderNodeImplPtr OslNetworkShaderGenerator::createShaderNodeImplForImplementation(const Implementation& /* implElement */) const
@@ -49,12 +154,14 @@ ShaderPtr OslNetworkShaderGenerator::generate(const string& name, ElementPtr ele
 
     if (context.getOptions().oslConnectCiWrapper)
     {
-        addSetCiTerminalNode(graph, element->getDocument(), context);
+        OslShaderGenerator::addSetCiTerminalNode(graph, element->getDocument(), getTypeSystem(), context);
     }
 
+    graph.flattenGraph();
+    graph.topologicalSort();
+
     ConstDocumentPtr document = element->getDocument();
 
-    string lastNodeName;
     ShaderOutput* lastOutput = nullptr;
     std::vector<string> connections;
 
@@ -67,55 +174,52 @@ ShaderPtr OslNetworkShaderGenerator::generate(const string& name, ElementPtr ele
 
         for (auto&& input : node->getInputs())
         {
-            string inputName = input->getName();
-            _syntax->makeValidName(inputName);
+            string inputName = node->getPortName(input->getName());
+
+            ValuePtr inputValue = input->getValue();
+            TypeDesc inputType = input->getType();
 
             const ShaderOutput* connection = input->getConnection();
             if (!connection || connection->getNode() == &graph)
             {
-                if (!input->hasAuthoredValue())
+                bool hasAuthoredValue = input->hasAuthoredValue();
+
+                if (connection && connection->getNode() == &graph)
+                {
+                    if (connection->getValue()) // why do this check?
+                    {
+                        inputValue = connection->getValue();
+                        hasAuthoredValue = connection->hasAuthoredValue();
+                        inputType = connection->getType();
+                    }
+                }
+
+                if (!inputValue)
+                    continue;
+
+                if (!hasAuthoredValue)
                     continue;
 
                 if (input->getName() == "backsurfaceshader" || input->getName() == "displacementshader")
                     continue; // FIXME: these aren't getting pruned by hasAuthoredValue
 
-                string value = _syntax->getValue(input);
-                if (value == "null_closure()")
-                    continue;
+                const TypeSyntax& typeSyntax = _syntax->getTypeSyntax(inputType);
 
-                // TODO: Figure out how to avoid special-casing struct-types in the generator, perhaps in the syntax?
-                auto inputType = input->getType();
-                if (inputType == Type::VECTOR2)
-                {
-                    auto parts = splitString(value, " ");
-                    emitLine(paramString(_syntax->getTypeName(Type::FLOAT), inputName + ".x", parts[0]), stage, false);
-                    emitLine(paramString(_syntax->getTypeName(Type::FLOAT), inputName + ".y", parts[1]), stage, false);
-                }
-                else if (inputType == Type::VECTOR4)
-                {
-                    auto parts = splitString(value, " ");
-                    emitLine(paramString(_syntax->getTypeName(Type::FLOAT), inputName + ".x", parts[0]), stage, false);
-                    emitLine(paramString(_syntax->getTypeName(Type::FLOAT), inputName + ".y", parts[1]), stage, false);
-                    emitLine(paramString(_syntax->getTypeName(Type::FLOAT), inputName + ".z", parts[2]), stage, false);
-                    emitLine(paramString(_syntax->getTypeName(Type::FLOAT), inputName + ".w", parts[3]), stage, false);
-                }
-                else if (inputType == Type::COLOR4)
-                {
-                    auto parts = splitString(value, " ");
-                    emitLine(paramString(_syntax->getTypeName(Type::COLOR3), inputName + ".rgb", parts[0] + " " + parts[1] + " " + parts[2]), stage, false);
-                    emitLine(paramString(_syntax->getTypeName(Type::FLOAT), inputName + ".a", parts[3]), stage, false);
-                }
-                else
+                const TypeSyntax* typeSyntaxPtr = &typeSyntax;
+
+                const OslNetworkSyntaxEmit* oslTypeSyntax = dynamic_cast<const OslNetworkSyntaxEmit*>(typeSyntaxPtr);
+
+                for (const auto& part : oslTypeSyntax->getEmitParamParts(inputName, inputType, *inputValue))
                 {
-                    emitLine(paramString(_syntax->getTypeName(input->getType()), inputName, value), stage, false);
+                    emitLine(paramString(part.typeName, part.paramName, part.paramValue), stage, false);
                 }
             }
             else
             {
-                string connName = connection->getName();
-                _syntax->makeValidName(connName);
+                string connName = connection->getNode()->getPortName(connection->getName());
 
-                string connect = connectString(connection->getNode()->getName(), connName, nodeName, inputName);
+                string fromNodeName = connection->getNode()->getName();
+                string connect = connectString(fromNodeName, connName, nodeName, inputName);
                 // Save connect emits for the end, because they can't come
                 // before both connected shaders have been declared.
                 connections.push_back(connect);
@@ -132,7 +236,6 @@ ShaderPtr OslNetworkShaderGenerator::generate(const string& name, ElementPtr ele
         osoPaths.insert(osoPath);
 
         emitLine("shader " + osoNodeImpl.getOsoName() + " " + nodeName + " ;", stage, false);
-        lastNodeName = nodeName;
     }
 
     if (!lastOutput)
@@ -155,7 +258,7 @@ ShaderPtr OslNetworkShaderGenerator::generate(const string& name, ElementPtr ele
         auto fullOsoPathStr = fullOsoPath.asString();
 
         osoPathStr += separator + fullOsoPathStr;
-        separator = ",";
+        separator = ":";
     }
 
     shader->setAttribute("osoPath", Value::createValue<string>(osoPathStr));
@@ -200,6 +303,160 @@ ShaderPtr OslNetworkShaderGenerator::createShader(const string& name, ElementPtr
     return shader;
 }
 
+bool OslNetworkShaderGenerator::compileOSL(const std::string& oslSourceCode, const FilePath& oslFilePath, const OslCompileOptions& options)
+{
+    if (!options.useOslComp && !options.writeSourceToDisk)
+    {
+        throw ExceptionShaderGenError("If OslComp library is not being used the source must be written to disk");
+    }
+
+    if (options.createDirectories)
+    {
+        oslFilePath.getParentPath().createDirectory(true);
+    }
+
+    if (!oslFilePath.getParentPath().isDirectory())
+    {
+        throw ExceptionShaderGenError("Cannot compile OSL shader, destination directory does not exist - '"+oslFilePath.getParentPath().asString()+"'");
+    }
+
+    if (options.writeSourceToDisk)
+    {
+        std::ofstream oslFile;
+        oslFile.open(oslFilePath);
+        oslFile << oslSourceCode;
+        oslFile.close();
+    }
+
+    FilePath osoFilePath = oslFilePath;
+    osoFilePath.removeExtension();
+    osoFilePath.addExtension("oso");
+
+    // build up a vector of compiler arguments that will be
+    // used in both compiler modes.
+    std::vector<std::string> oslCompilerArgs;
+    oslCompilerArgs.emplace_back("-o");
+    oslCompilerArgs.emplace_back(osoFilePath);
+    for (FilePath p : options.oslIncludePath)
+    {
+        oslCompilerArgs.emplace_back("-I" + p.asString() + "");
+    }
+
+#ifdef USE_OSLCOMP
+    if (options.useOslComp)
+    {
+        // Use OSL::oslcomp to compile the shader - this is significantly faster than using the system
+        // call to involke the `oslc` command line tool
+        OIIO::ErrorHandler errorHandler;
+        ::OSL::OSLCompiler compiler(&errorHandler);
+        if (options.writeSourceToDisk)
+        {
+            // Compile from the source file
+            compiler.compile(oslFilePath.asString(), oslCompilerArgs);
+        }
+        else
+        {
+            // Compile directly from the string buffer
+            std::string osoBuffer;
+            compiler.compile_buffer(oslSourceCode, osoBuffer, oslCompilerArgs, std::string_view(), oslFilePath.asString());
+
+            std::ofstream osoFile;
+            osoFile.open(osoFilePath.asString());
+            osoFile << osoBuffer;
+            osoFile.close();
+        }
+    }
+    else
+#endif
+    {
+        // If no command and include path specified then skip checking.
+        if (options.oslCompilerPath.isEmpty())
+        {
+            throw ExceptionShaderGenError("OSL compiler path missing");
+        }
+        if (!options.oslCompilerPath.exists())
+        {
+            throw ExceptionShaderGenError("OSL compiler doesn't exist at '" + options.oslCompilerPath.asString() + "'");
+        }
+
+        // Use a known error file name to check
+        std::string errorFile(osoFilePath.asString() + "_compile_errors.txt");
+        const std::string redirectString(" 2>&1");
+
+        // Run the command and get back the result. If non-empty string throw exception with error
+        std::string command = options.oslCompilerPath.asString() + " -q " + oslFilePath.asString();
+        for (const auto& arg : oslCompilerArgs)
+        {
+            command += " " + arg;
+        }
+        command += " > " + errorFile + redirectString;
+
+        int returnValue = std::system(command.c_str());
+
+        std::ifstream errorStream(errorFile);
+        std::string result;
+        result.assign(std::istreambuf_iterator<char>(errorStream),
+                      std::istreambuf_iterator<char>());
+
+        if (!result.empty())
+        {
+            StringVec errors;
+            errors.push_back("Command string: " + command);
+            errors.push_back("Command return code: " + std::to_string(returnValue));
+            errors.push_back("Shader failed to compile:");
+            errors.push_back(result);
+            throw ExceptionOslCompileError("OSL compilation error", errors);
+        }
+    }
+
+    return true;
+}
+
+ShaderPtr OslNetworkShaderGenerator::generateOSLShader(ConstNodeDefPtr nodeDef, OslShaderGeneratorPtr generator, GenContext& context, const string& osoNameStrategy)
+{
+    if (!generator)
+    {
+        // raise error
+        return nullptr;
+    }
+
+    // Determine whether or not there's a valid implementation of the current `NodeDef` for the type associated
+    // to our OSL shader generator, i.e. OSL, and if not, skip it.
+    InterfaceElementPtr nodeImpl = nodeDef->getImplementation(generator->getTarget(), false);
+
+    if (!nodeImpl)
+    {
+        std::cout << "The following `NodeDef` does not provide a valid OSL implementation, "
+                     "and will be skipped: "
+                  << nodeDef->getName() << std::endl;
+
+        return nullptr;
+    }
+
+    // Intention is here is to name the new node the same as the genosl implementation name
+    // but replacing "_genosl" with "_genoslnetwork"
+    std::string nodeName;
+    if (osoNameStrategy == "implementation")
+    {
+        // Name the node the same as the implementation with _genoslnetwork added as a suffix.
+        // NOTE : If the implementation currently has _genosl as a suffix then we remove it.
+        nodeName = nodeImpl->getName();
+        nodeName = replaceSubstrings(nodeName, { { "_genosl", "" } });
+        nodeName += "_genoslnetwork";
+    }
+    else
+    {
+        // Name the node the same as the node definition
+        nodeName = nodeDef->getName();
+    }
+
+    // We shouldn't need to do this - but it doesn't hurt just to be safe.
+    generator->getSyntax().makeValidName(nodeName);
+
+    // Codegen the `Node` to OSL.
+    return generator->generate(nodeName, std::const_pointer_cast<NodeDef>(nodeDef), context);
+}
+
 namespace OSLNetwork
 {
 
diff --git a/source/MaterialXGenOsl/OslNetworkShaderGenerator.h b/source/MaterialXGenOsl/OslNetworkShaderGenerator.h
index 3cb3fcda9f..2bf97a014a 100644
--- a/source/MaterialXGenOsl/OslNetworkShaderGenerator.h
+++ b/source/MaterialXGenOsl/OslNetworkShaderGenerator.h
@@ -20,7 +20,7 @@ using OslNetworkShaderGeneratorPtr = shared_ptr<class OslNetworkShaderGenerator>
 /// @class OslNetworkShaderGenerator
 /// OSL (Open Shading Language) Network shader generator.
 /// Generates a command string that OSL can use to build a ShaderGroup.
-class MX_GENOSL_API OslNetworkShaderGenerator : public OslShaderGenerator
+class MX_GENOSL_API OslNetworkShaderGenerator : public ShaderGenerator
 {
   public:
     /// Constructor.
@@ -45,12 +45,59 @@ class MX_GENOSL_API OslNetworkShaderGenerator : public OslShaderGenerator
     /// the element and all dependencies upstream into shader code.
     ShaderPtr generate(const string& name, ElementPtr element, GenContext& context) const override;
 
+    ShaderNodeImplPtr getImplementation(const NodeDef& nodedef, GenContext& context) const override;
+
     /// Unique identifier for this generator target
     static const string TARGET;
 
+    /// A set of options for controlling the behavior of OSL compilation.
+    struct OslCompileOptions
+    {
+        FilePath oslCompilerPath;
+        FileSearchPath oslIncludePath;
+        bool useOslComp = false;
+        bool writeSourceToDisk = true;
+        bool createDirectories = true;
+    };
+
+    static bool compileOSL(const std::string& oslSourceCode, const FilePath& oslFilePath, const OslCompileOptions& options);
+
+    static ShaderPtr generateOSLShader(ConstNodeDefPtr nodeDef, OslShaderGeneratorPtr generator, GenContext& context, const string& osoNameStrategy = "implementation");
+
   protected:
     /// Create and initialize a new OSL shader for shader generation.
-    ShaderPtr createShader(const string& name, ElementPtr element, GenContext& context) const override;
+    ShaderPtr createShader(const string& name, ElementPtr element, GenContext& context) const;
+};
+
+class MX_GENOSL_API ExceptionOslCompileError : public Exception
+{
+public:
+    ExceptionOslCompileError(const std::string& msg, const StringVec& errorLog = StringVec()) :
+        Exception(msg),
+        _errorLog(errorLog)
+    {
+    }
+
+    ExceptionOslCompileError(const ExceptionOslCompileError& e) :
+        Exception(e),
+        _errorLog(e._errorLog)
+    {
+    }
+
+    ExceptionOslCompileError& operator=(const ExceptionOslCompileError& e)
+    {
+        Exception::operator=(e);
+        _errorLog = e._errorLog;
+        return *this;
+    }
+
+    const StringVec& errorLog() const
+    {
+        return _errorLog;
+    }
+
+private:
+    StringVec _errorLog;
 };
 
 namespace OSLNetwork
diff --git a/source/MaterialXGenOsl/OslNetworkSyntax.cpp b/source/MaterialXGenOsl/OslNetworkSyntax.cpp
index eed0c163a8..149978dcbb 100644
--- a/source/MaterialXGenOsl/OslNetworkSyntax.cpp
+++ b/source/MaterialXGenOsl/OslNetworkSyntax.cpp
@@ -14,140 +14,70 @@ MATERIALX_NAMESPACE_BEGIN
 namespace
 {
 
-template <class T>
-class OslNetworkVectorTypeSyntax : public AggregateTypeSyntax
+class OslNetworkTypeSyntax : public TypeSyntax
 {
-  public:
-    OslNetworkVectorTypeSyntax(const Syntax* parent, const string& name, const string& defaultValue, const string& uniformDefaultValue,
-                             const string& typeAlias = EMPTY_STRING, const string& typeDefinition = EMPTY_STRING,
-                             const StringVec& members = EMPTY_MEMBERS) :
-        AggregateTypeSyntax(parent, name, defaultValue, uniformDefaultValue, typeAlias, typeDefinition, members)
+public:
+    OslNetworkTypeSyntax(const Syntax* parent, const string& name) :
+        TypeSyntax(parent, name, EMPTY_STRING, EMPTY_STRING, EMPTY_STRING, EMPTY_STRING, EMPTY_MEMBERS)
     {
     }
+    virtual ~OslNetworkTypeSyntax() = default;
 
     string getValue(const Value& value, bool /*uniform*/) const override
     {
-        // param string values are space-separated, not comma-separated
-        T c = value.asA<T>();
-
-        string result = "";
-        string separator = "";
-        for (size_t i = 0; i < c.numElements(); i++) {
-            result += separator;
-            result += toValueString(c[i]);
-
-            separator = " ";
-        }
-
-        return result;
-
-    }
-};
-
-class OslBooleanTypeSyntax : public ScalarTypeSyntax
-{
-  public:
-    OslBooleanTypeSyntax(const Syntax* parent) :
-        ScalarTypeSyntax(parent, "int", "0", "0", EMPTY_STRING, "#define true 1\n#define false 0")
-    {
-    }
-
-    string getValue(const Value& value, bool /*uniform*/) const override
-    {
-        return value.asA<bool>() ? "1" : "0";
-    }
-};
-
-class OslArrayTypeSyntax : public ScalarTypeSyntax
-{
-  public:
-    OslArrayTypeSyntax(const Syntax* parent, const string& name) :
-        ScalarTypeSyntax(parent, name, EMPTY_STRING, EMPTY_STRING, EMPTY_STRING)
-    {
-    }
-
-    string getValue(const Value& value, bool uniform) const override
-    {
-        if (!isEmpty(value))
-        {
-            return "{" + value.getValueString() + "}";
-        }
-        // OSL disallows arrays without initialization when specified as input uniform
-        else if (uniform)
-        {
-            throw ExceptionShaderGenError("Uniform array cannot initialize to a empty value.");
-        }
-        return EMPTY_STRING;
+        return value.getValueString();
     }
-
-  protected:
-    virtual bool isEmpty(const Value& value) const = 0;
 };
 
-class OslFloatArrayTypeSyntax : public OslArrayTypeSyntax
+class OslNetworkConnectionOnlyTypeSyntax : public OslNetworkTypeSyntax, public OslNetworkSyntaxEmit
 {
   public:
-    explicit OslFloatArrayTypeSyntax(const Syntax* parent, const string& name) :
-        OslArrayTypeSyntax(parent, name)
+    OslNetworkConnectionOnlyTypeSyntax(const Syntax* parent, const string& name) :
+        OslNetworkTypeSyntax(parent, name)
     {
     }
+    virtual ~OslNetworkConnectionOnlyTypeSyntax() = default;
 
-  protected:
-    bool isEmpty(const Value& value) const override
+    EmitParamPartVec getEmitParamParts(const string& /*name*/, TypeDesc /*typeDesc*/, const Value& /*value*/) const override
     {
-        vector<float> valueArray = value.asA<vector<float>>();
-        return valueArray.empty();
+        throw ExceptionShaderGenError("Param set for connection only param");
     }
 };
 
-class OslIntegerArrayTypeSyntax : public OslArrayTypeSyntax
+class OslNetworkScalarTypeSyntax : public OslNetworkTypeSyntax, public OslNetworkSyntaxEmit
 {
   public:
-    explicit OslIntegerArrayTypeSyntax(const Syntax* parent, const string& name) :
-        OslArrayTypeSyntax(parent, name)
+    OslNetworkScalarTypeSyntax(const Syntax* parent, const string& name) :
+        OslNetworkTypeSyntax(parent, name)
     {
     }
+    virtual ~OslNetworkScalarTypeSyntax() = default;
 
-  protected:
-    bool isEmpty(const Value& value) const override
+    EmitParamPartVec getEmitParamParts(const string& name, TypeDesc /*typeDesc*/, const Value& value) const override
     {
-        vector<int> valueArray = value.asA<vector<int>>();
-        return valueArray.empty();
+        return { { _name, name, getValue(value, true) } };
     }
 };
 
-// In OSL vector2, vector4, and color4 are custom struct types and require a different
-// value syntax for uniforms. So override the aggregate type syntax to support this.
-class OslStructTypeSyntax : public AggregateTypeSyntax
+class OslNetworkBooleanTypeSyntax : public OslNetworkScalarTypeSyntax
 {
   public:
-    OslStructTypeSyntax(const Syntax* parent, const string& name, const string& defaultValue, const string& uniformDefaultValue,
-                        const string& typeAlias = EMPTY_STRING, const string& typeDefinition = EMPTY_STRING,
-                        const StringVec& members = EMPTY_MEMBERS) :
-        AggregateTypeSyntax(parent, name, defaultValue, uniformDefaultValue, typeAlias, typeDefinition, members)
+    OslNetworkBooleanTypeSyntax(const Syntax* parent) :
+        OslNetworkScalarTypeSyntax(parent, "int")
     {
     }
 
-    string getValue(const Value& value, bool uniform) const override
+    string getValue(const Value& value, bool /*uniform*/) const override
     {
-        if (uniform)
-        {
-            return "{" + value.getValueString() + "}";
-        }
-        else
-        {
-            return getName() + "(" + value.getValueString() + ")";
-        }
+        return value.asA<bool>() ? "1" : "0";
     }
 };
 
-class OSLMatrix3TypeSyntax : public AggregateTypeSyntax
+class OslNetworkMatrix3TypeSyntax : public OslNetworkScalarTypeSyntax
 {
   public:
-    OSLMatrix3TypeSyntax(const Syntax* parent, const string& name, const string& defaultValue, const string& uniformDefaultValue,
-                         const string& typeAlias = EMPTY_STRING, const string& typeDefinition = EMPTY_STRING,
-                         const StringVec& members = EMPTY_MEMBERS) :
-        AggregateTypeSyntax(parent, name, defaultValue, uniformDefaultValue, typeAlias, typeDefinition, members)
+    OslNetworkMatrix3TypeSyntax(const Syntax* parent, const string& name) :
+        OslNetworkScalarTypeSyntax(parent, name)
     {
     }
 
@@ -159,92 +89,136 @@ class OSLMatrix3TypeSyntax : public AggregateTypeSyntax
             throw ExceptionShaderGenError("No values given to construct a value");
         }
 
-        // Write the value using a stream to maintain any float formatting set
-        // using Value::setFloatFormat() and Value::setFloatPrecision()
         StringStream ss;
-        ss << getName() << "(";
         for (size_t i = 0; i < values.size(); i++)
         {
-            ss << values[i] << ", ";
+            ss << values[i] << " ";
             if ((i + 1) % 3 == 0)
             {
                 ss << "0.000"
-                   << ", ";
+                    << " ";
             }
         }
-        static string ROW_4("0.000, 0.000, 0.000, 1.000");
-        ss << ROW_4 << ")";
+        static string ROW_4("0.000  0.000  0.000  1.000");
+        ss << ROW_4;
 
         return ss.str();
     }
 };
 
-class OSLFilenameTypeSyntax : public AggregateTypeSyntax
+template <class T>
+class OslNetworkVectorStructTypeSyntax : public OslNetworkTypeSyntax, public OslNetworkSyntaxEmit
+{
+  public:
+    OslNetworkVectorStructTypeSyntax(const Syntax* parent, const string& name) :
+        OslNetworkTypeSyntax(parent, name)
+    {
+    }
+
+    EmitParamPartVec getEmitParamParts(const string& name, TypeDesc typeDesc, const Value& value) const override;
+};
+
+template <>
+OslNetworkSyntaxEmit::EmitParamPartVec OslNetworkVectorStructTypeSyntax<Vector2>::getEmitParamParts(const string& name, TypeDesc /*typeDesc*/, const Value& value) const
+{
+    const TypedValue<Vector2>& vec2Value = static_cast<const TypedValue<Vector2>&>(value);
+    const Vector2& vec2 = vec2Value.getData();
+    return {
+        { "float", name + ".x", std::to_string(vec2[0]) },
+        { "float", name + ".y", std::to_string(vec2[1]) },
+    };
+}
+
+template <>
+OslNetworkSyntaxEmit::EmitParamPartVec OslNetworkVectorStructTypeSyntax<Vector4>::getEmitParamParts(const string& name, TypeDesc /*typeDesc*/, const Value& value) const
+{
+    const TypedValue<Vector4>& vec4Value = static_cast<const TypedValue<Vector4>&>(value);
+    const Vector4& vec4 = vec4Value.getData();
+    return {
+        { "float", name + ".x", std::to_string(vec4[0]) },
+        { "float", name + ".y", std::to_string(vec4[1]) },
+        { "float", name + ".z", std::to_string(vec4[2]) },
+        { "float", name + ".w", std::to_string(vec4[3]) },
+    };
+}
+
+template <>
+OslNetworkSyntaxEmit::EmitParamPartVec OslNetworkVectorStructTypeSyntax<Color4>::getEmitParamParts(const string& name, TypeDesc /*typeDesc*/, const Value& value) const
+{
+    const TypedValue<Color4>& col4Value = static_cast<const TypedValue<Color4>&>(value);
+    const Color4& col4 = col4Value.getData();
+    return {
+        { "color", name + ".rgb", std::to_string(col4[0]) + " " + std::to_string(col4[1]) + " " + std::to_string(col4[2]) },
+        { "float", name + ".a", std::to_string(col4[3]) },
+    };
+}
+
+class OslNetworkFloatTupleTypeSyntax : public OslNetworkScalarTypeSyntax
+{
+public:
+    OslNetworkFloatTupleTypeSyntax(const Syntax* parent, const string& name) :
+        OslNetworkScalarTypeSyntax(parent, name)
+    {
+    }
+
+    string getValue(const Value& value, bool /*uniform*/) const override
+    {
+        string valStr = value.getValueString();
+        return replaceSubstrings(valStr, { { ",", " " } });
+    }
+};
+
+template <class T>
+class OslNetworkArrayTypeSyntax : public OslNetworkScalarTypeSyntax
 {
   public:
-    OSLFilenameTypeSyntax(const Syntax* parent, const string& name, const string& defaultValue, const string& uniformDefaultValue,
-                          const string& typeAlias = EMPTY_STRING, const string& typeDefinition = EMPTY_STRING,
-                          const StringVec& members = EMPTY_MEMBERS) :
-        AggregateTypeSyntax(parent, name, defaultValue, uniformDefaultValue, typeAlias, typeDefinition, members)
+    OslNetworkArrayTypeSyntax(const Syntax* parent, const string& name) :
+        OslNetworkScalarTypeSyntax(parent, name)
+    {
+    }
+
+    EmitParamPartVec getEmitParamParts(const string& /*name*/, TypeDesc /*typeDesc*/, const Value& /*value*/) const override
     {
+        throw ExceptionShaderGenError("OSL Network array output unimplemented - no nodes use array inputs currently");
+        return {};
     }
 
-    string getValue(const ShaderPort* port, bool /*uniform*/) const override
+    string getValue(const Value& value, bool uniform) const override
     {
-        if (!port)
+        if (!isEmpty(value))
         {
-            return EMPTY_STRING;
+            return "{" + value.getValueString() + "}";
         }
-
-        const string filename = port->getValue() ? port->getValue()->getValueString() : EMPTY_STRING;
-        return filename;
+        // OSL disallows arrays without initialization when specified as input uniform
+        else if (uniform)
+        {
+            throw ExceptionShaderGenError("Uniform array cannot initialize to a empty value.");
+        }
+        return EMPTY_STRING;
     }
 
-    string getValue(const Value& value, bool /*uniform*/) const override
+  protected:
+    bool isEmpty(const Value& value) const
     {
-        return value.getValueString();
+        vector<T> valueArray = value.asA<vector<T>>();
+        return valueArray.empty();
     }
 };
 
 } // anonymous namespace
 
-const string OslNetworkSyntax::OUTPUT_QUALIFIER = "output";
-const string OslNetworkSyntax::SOURCE_FILE_EXTENSION = ".osl";
-const StringVec OslNetworkSyntax::VECTOR_MEMBERS = { "[0]", "[1]", "[2]" };
-const StringVec OslNetworkSyntax::VECTOR2_MEMBERS = { ".x", ".y" };
-const StringVec OslNetworkSyntax::VECTOR4_MEMBERS = { ".x", ".y", ".z", ".w" };
-const StringVec OslNetworkSyntax::COLOR4_MEMBERS = { ".rgb[0]", ".rgb[1]", ".rgb[2]", ".a" };
-
 //
 // OslNetworkSyntax methods
 //
 
-OslNetworkSyntax::OslNetworkSyntax(TypeSystemPtr typeSystem) : Syntax(typeSystem)
+OslNetworkSyntax::OslNetworkSyntax(TypeSystemPtr typeSystem) :
+    Syntax(typeSystem)
 {
-    // Add in all reserved words and keywords in OSL
-    registerReservedWords(
-        { // OSL types and keywords
-          "and", "break", "closure", "color", "continue", "do", "else", "emit", "float", "for", "if", "illuminance",
-          "illuminate", "int", "matrix", "normal", "not", "or", "output", "point", "public", "return", "string",
-          "struct", "vector", "void", "while",
-          "bool", "case", "catch", "char", "class", "const", "delete", "default", "double", "enum", "extern",
-          "false", "friend", "goto", "inline", "long", "new", "operator", "private", "protected", "short",
-          "signed", "sizeof", "static", "switch", "template", "this", "throw", "true", "try", "typedef", "uniform",
-          "union", "unsigned", "varying", "virtual", "volatile",
-          // OSL standard library functions names
-          "degrees", "radians", "cos", "sin", "tan", "acos", "asin", "atan", "atan2", "cosh", "sinh", "tanh",
-          "pow", "log", "log2", "log10", "logb", "sqrt", "inversesqrt", "cbrt", "hypot", "abs", "fabs", "sign",
-          "floor", "ceil", "round", "trunc", "fmod", "mod", "min", "max", "clamp", "mix", "select", "isnan",
-          "isinf", "isfinite", "erf", "erfc", "cross", "dot", "length", "distance", "normalize", "faceforward",
-          "reflect", "fresnel", "transform", "transformu", "rotate", "luminance", "blackbody", "wavelength_color",
-          "transformc", "determinant", "transpose", "step", "smoothstep", "linearstep", "smooth_linearstep", "aastep",
-          "hash", "strlen", "getchar", "startswith", "endswith", "substr", "stof", "stoi", "concat", "textureresource",
-          "backfacing", "raytype", "iscameraray", "isdiffuseray", "isglossyray", "isshadowray", "getmatrix",
-          "emission", "background", "diffuse", "oren_nayer", "translucent", "phong", "ward", "microfacet",
-          "reflection", "transparent", "debug", "holdout", "subsurface", "sheen",
-          "oren_nayar_diffuse_bsdf", "burley_diffuse_bsdf", "dielectric_bsdf", "conductor_bsdf", "generalized_schlick_bsdf",
-          "translucent_bsdf", "transparent_bsdf", "subsurface_bssrdf", "sheen_bsdf", "uniform_edf", "anisotropic_vdf",
-          "medium_vdf", "layer", "artistic_ior" });
+    // We don't add any reserved words to the OSL Network syntax
+    // even the three "words" used in the construction of the OSL
+    // shader group string, "shader", "param" and "connect, are not
+    // reserved. The structure of the command string ensures
+    // no ambiguity if they are used as names.
 
     //
     // Register type syntax handlers for each data type.
@@ -252,213 +226,195 @@ OslNetworkSyntax::OslNetworkSyntax(TypeSystemPtr typeSystem) : Syntax(typeSystem
 
     registerTypeSyntax(
         Type::FLOAT,
-        std::make_shared<ScalarTypeSyntax>(
+        std::make_shared<OslNetworkScalarTypeSyntax>(
             this,
-            "float",
-            "0.0",
-            "0.0"));
+            "float"));
 
     registerTypeSyntax(
         Type::FLOATARRAY,
-        std::make_shared<OslFloatArrayTypeSyntax>(
+        std::make_shared<OslNetworkArrayTypeSyntax<float>>(
             this,
             "float"));
 
     registerTypeSyntax(
         Type::INTEGER,
-        std::make_shared<ScalarTypeSyntax>(
+        std::make_shared<OslNetworkScalarTypeSyntax>(
             this,
-            "int",
-            "0",
-            "0"));
+            "int"));
 
     registerTypeSyntax(
         Type::INTEGERARRAY,
-        std::make_shared<OslIntegerArrayTypeSyntax>(
+        std::make_shared<OslNetworkArrayTypeSyntax<int>>(
             this,
             "int"));
 
     registerTypeSyntax(
         Type::BOOLEAN,
-        std::make_shared<OslBooleanTypeSyntax>(this));
+        std::make_shared<OslNetworkBooleanTypeSyntax>(this));
 
     registerTypeSyntax(
-        // Note: the color type in OSL is a built in type and
-        // should not use the custom OslStructTypeSyntax.
         Type::COLOR3,
-        std::make_shared<OslNetworkVectorTypeSyntax<Color3>>(
+        std::make_shared<OslNetworkFloatTupleTypeSyntax>(
             this,
-            "color",
-            "color(0.0)",
-            "color(0.0)",
-            EMPTY_STRING,
-            EMPTY_STRING,
-            VECTOR_MEMBERS));
+            "color"));
 
     registerTypeSyntax(
         Type::COLOR4,
-        std::make_shared<OslNetworkVectorTypeSyntax<Color4>>(
+        std::make_shared<OslNetworkVectorStructTypeSyntax<Color4>>(
             this,
-            "color",
-            "color(0.0)",
-            "color(0.0)",
-            EMPTY_STRING,
-            EMPTY_STRING,
-            VECTOR4_MEMBERS));
+            "color4"));
 
     registerTypeSyntax(
         Type::VECTOR2,
-        std::make_shared<OslNetworkVectorTypeSyntax<Vector2>>(
+        std::make_shared<OslNetworkVectorStructTypeSyntax<Vector2>>(
             this,
-            "vector2",
-            "vector2(0.0, 0.0)",
-            "{0.0, 0.0}",
-            EMPTY_STRING,
-            EMPTY_STRING,
-            VECTOR2_MEMBERS));
+            "vector2"));
 
     registerTypeSyntax(
-        // Note: the vector type in OSL is a built in type and
-        // should not use the custom OslStructTypeSyntax.
         Type::VECTOR3,
-        std::make_shared<OslNetworkVectorTypeSyntax<Vector3>>(
+        std::make_shared<OslNetworkFloatTupleTypeSyntax>(
             this,
-            "vector",
-            "vector(0.0)",
-            "vector(0.0)",
-            EMPTY_STRING,
-            EMPTY_STRING,
-            VECTOR_MEMBERS));
+            "vector"));
 
     registerTypeSyntax(
         Type::VECTOR4,
-        std::make_shared<OslNetworkVectorTypeSyntax<Vector4>>(
+        std::make_shared<OslNetworkVectorStructTypeSyntax<Vector4>>(
             this,
-            "vector4",
-            "vector4(0.0, 0.0, 0.0, 0.0)",
-            "{0.0, 0.0, 0.0, 0.0}",
-            EMPTY_STRING,
-            EMPTY_STRING,
-            VECTOR4_MEMBERS));
+            "vector4"));
 
     registerTypeSyntax(
         Type::MATRIX33,
-        std::make_shared<OSLMatrix3TypeSyntax>(
+        std::make_shared<OslNetworkMatrix3TypeSyntax>(
             this,
-            "matrix",
-            "matrix(1.0)",
-            "matrix(1.0)"));
+            "matrix"));
 
     registerTypeSyntax(
         Type::MATRIX44,
-        std::make_shared<AggregateTypeSyntax>(
+        std::make_shared<OslNetworkFloatTupleTypeSyntax>(
             this,
-            "matrix",
-            "matrix(1.0)",
-            "matrix(1.0)"));
+            "matrix"));
 
     registerTypeSyntax(
         Type::STRING,
-        std::make_shared<StringTypeSyntax>(
+        std::make_shared<OslNetworkScalarTypeSyntax>(
             this,
-            "string",
-            "\"\"",
-            "\"\""));
+            "string"));
 
     registerTypeSyntax(
         Type::FILENAME,
-        std::make_shared<OSLFilenameTypeSyntax>(
+        std::make_shared<OslNetworkScalarTypeSyntax>(
             this,
-            "string",
-            "textureresource (\"\", \"\")",
-            "(\"\", \"\")",
-            EMPTY_STRING,
-            "struct textureresource { string filename; string colorspace; };"));
+            "string"));
 
     registerTypeSyntax(
         Type::BSDF,
-        std::make_shared<ScalarTypeSyntax>(
+        std::make_shared<OslNetworkConnectionOnlyTypeSyntax>(
             this,
-            "BSDF",
-            "null_closure()",
-            "0",
-            "closure color",
-            "#define BSDF closure color"));
+            "BSDF"));
 
     registerTypeSyntax(
         Type::EDF,
-        std::make_shared<ScalarTypeSyntax>(
+        std::make_shared<OslNetworkConnectionOnlyTypeSyntax>(
             this,
-            "EDF",
-            "null_closure()",
-            "0",
-            "closure color",
-            "#define EDF closure color"));
+            "EDF"));
 
     registerTypeSyntax(
         Type::VDF,
-        std::make_shared<ScalarTypeSyntax>(
+        std::make_shared<OslNetworkConnectionOnlyTypeSyntax>(
             this,
-            "VDF",
-            "null_closure()",
-            "0",
-            "closure color",
-            "#define VDF closure color"));
+            "VDF"));
 
     registerTypeSyntax(
         Type::SURFACESHADER,
-        std::make_shared<AggregateTypeSyntax>(
+        std::make_shared<OslNetworkConnectionOnlyTypeSyntax>(
             this,
-            "surfaceshader",
-            "surfaceshader(null_closure(), null_closure(), 1.0)",
-            "{ 0, 0, 1.0 }",
-            "closure color",
-            "struct surfaceshader { closure color bsdf; closure color edf; float opacity; };"));
+            "surfaceshader"));
 
     registerTypeSyntax(
         Type::VOLUMESHADER,
-        std::make_shared<ScalarTypeSyntax>(
+        std::make_shared<OslNetworkConnectionOnlyTypeSyntax>(
             this,
-            "volumeshader",
-            "null_closure()",
-            "0",
-            "closure color",
-            "#define volumeshader closure color"));
+            "volumeshader"));
 
     registerTypeSyntax(
         Type::DISPLACEMENTSHADER,
-        std::make_shared<ScalarTypeSyntax>(
+        std::make_shared<OslNetworkConnectionOnlyTypeSyntax>(
             this,
-            "displacementshader",
-            "vector(0.0)",
-            "vector(0.0)",
-            "vector",
-            "#define displacementshader vector"));
+            "displacementshader"));
 
     registerTypeSyntax(
         Type::LIGHTSHADER,
-        std::make_shared<ScalarTypeSyntax>(
+        std::make_shared<OslNetworkConnectionOnlyTypeSyntax>(
             this,
-            "lightshader",
-            "null_closure()",
-            "0",
-            "closure color",
-            "#define lightshader closure color"));
+            "lightshader"));
 
     registerTypeSyntax(
         Type::MATERIAL,
-        std::make_shared<ScalarTypeSyntax>(
+        std::make_shared<OslNetworkConnectionOnlyTypeSyntax>(
             this,
-            "MATERIAL",
-            "null_closure()",
-            "0",
-            "closure color",
-            "#define MATERIAL closure color"));
+            "MATERIAL"));
 }
 
-const string& OslNetworkSyntax::getOutputQualifier() const
+StructTypeSyntaxPtr OslNetworkSyntax::createStructSyntax(const string& structTypeName, const string& defaultValue,
+                                                         const string& uniformDefaultValue, const string& typeAlias,
+                                                         const string& typeDefinition) const
 {
-    return OUTPUT_QUALIFIER;
+    return std::make_shared<OslNetworkStructTypeSyntax>(
+        this,
+        structTypeName,
+        defaultValue,
+        uniformDefaultValue,
+        typeAlias,
+        typeDefinition);
+}
+
+OslNetworkStructTypeSyntax::OslNetworkStructTypeSyntax(const Syntax* parent, const string& name, const string& defaultValue, const string& uniformDefaultValue,
+                                                       const string& typeAlias, const string& typeDefinition,
+                                                       const StringVec& members) :
+    StructTypeSyntax(parent, name, defaultValue, uniformDefaultValue, typeAlias, typeDefinition, members)
+{
+}
+
+OslNetworkSyntaxEmit::EmitParamPartVec OslNetworkStructTypeSyntax::getEmitParamParts(const string& name, TypeDesc typeDesc, const Value& value) const
+{
+    EmitParamPartVec result;
+
+    const AggregateValue& aggregateValue = dynamic_cast<const AggregateValue&>(value);
+
+    StructMemberDescVecPtr structMembers = typeDesc.getStructMembers();
+    if (!structMembers)
+    {
+        // we expect to get members in a struct - raise an error here?
+        throw ExceptionShaderGenError("Expected to find struct members.");
+    }
+
+    unsigned int memberIndex = 0;
+    for (const auto& member : *structMembers)
+    {
+        TypeDesc memberType = member.getType();
+        ConstValuePtr memberValue = aggregateValue.getMemberValue(memberIndex);
+
+        const TypeSyntax* memberTypeSyntax = &(_parent->getTypeSyntax(memberType));
+        const OslNetworkSyntaxEmit* memberOslTypeSyntaxPtr = dynamic_cast<const OslNetworkSyntaxEmit*>(memberTypeSyntax);
+        if (!memberOslTypeSyntaxPtr)
+        {
+            throw ExceptionShaderGenError("Could not cast to OslNetworkSyntaxEmit syntax type");
+        }
+
+        // Get the respective param parts for each member of the struct
+        // and then add to the final result prefixing the name with the name of the struct currently being processed.
+        EmitParamPartVec emitParamParts = memberOslTypeSyntaxPtr->getEmitParamParts(member.getName(), memberType, *memberValue);
+        for (const EmitParamPart& paramPart : emitParamParts)
+        {
+            result.emplace_back(EmitParamPart(paramPart.typeName, name + "." + paramPart.paramName, paramPart.paramValue));
+        }
+
+        memberIndex++;
+    }
+
+    return result;
 }
 
+OslNetworkStructTypeSyntax::~OslNetworkStructTypeSyntax() { }
+
 MATERIALX_NAMESPACE_END
diff --git a/source/MaterialXGenOsl/OslNetworkSyntax.h b/source/MaterialXGenOsl/OslNetworkSyntax.h
index 1ec6d30780..d34aa6d0e8 100644
--- a/source/MaterialXGenOsl/OslNetworkSyntax.h
+++ b/source/MaterialXGenOsl/OslNetworkSyntax.h
@@ -24,18 +24,50 @@ class MX_GENOSL_API OslNetworkSyntax : public Syntax
 
     static SyntaxPtr create(TypeSystemPtr typeSystem) { return std::make_shared<OslNetworkSyntax>(typeSystem); }
 
-    const string& getOutputQualifier() const override;
+    StructTypeSyntaxPtr createStructSyntax(const string& structTypeName, const string& defaultValue,
+                                           const string& uniformDefaultValue, const string& typeAlias,
+                                           const string& typeDefinition) const override;
+
+    const string& getOutputQualifier() const override { return EMPTY_STRING; };
     const string& getConstantQualifier() const override { return EMPTY_STRING; };
-    const string& getSourceFileExtension() const override { return SOURCE_FILE_EXTENSION; };
+    const string& getSourceFileExtension() const override { return EMPTY_STRING; };
 
-    static const string OUTPUT_QUALIFIER;
-    static const string SOURCE_FILE_EXTENSION;
     static const StringVec VECTOR_MEMBERS;
     static const StringVec VECTOR2_MEMBERS;
     static const StringVec VECTOR4_MEMBERS;
     static const StringVec COLOR4_MEMBERS;
 };
 
+/// Interface class for exporting OSL commands for parameters
+class MX_GENOSL_API OslNetworkSyntaxEmit
+{
+public:
+    struct EmitParamPart
+    {
+        EmitParamPart(const string& type, const string& name, const string& value) :
+            typeName(type), paramName(name), paramValue(value) { }
+        string typeName;
+        string paramName;
+        string paramValue;
+    };
+    using EmitParamPartVec = vector<EmitParamPart>;
+
+    virtual EmitParamPartVec getEmitParamParts(const string& name, TypeDesc typeDesc, const Value& value) const = 0;
+};
+
+
+/// Specialization of TypeSyntax for struct types.
+class MX_GENOSL_API OslNetworkStructTypeSyntax : public StructTypeSyntax, public OslNetworkSyntaxEmit
+{
+public:
+    OslNetworkStructTypeSyntax(const Syntax* parent, const string& name, const string& defaultValue, const string& uniformDefaultValue,
+                     const string& typeAlias = EMPTY_STRING, const string& typeDefinition = EMPTY_STRING,
+                     const StringVec& members = EMPTY_MEMBERS);
+    virtual ~OslNetworkStructTypeSyntax();
+
+    EmitParamPartVec getEmitParamParts(const string& name, TypeDesc typeDesc, const Value& value) const override;
+};
+
 MATERIALX_NAMESPACE_END
 
 #endif
diff --git a/source/MaterialXGenOsl/OslShaderGenerator.cpp b/source/MaterialXGenOsl/OslShaderGenerator.cpp
index 94da1dc77b..70681f6c74 100644
--- a/source/MaterialXGenOsl/OslShaderGenerator.cpp
+++ b/source/MaterialXGenOsl/OslShaderGenerator.cpp
@@ -26,6 +26,21 @@ OslShaderGenerator::OslShaderGenerator(TypeSystemPtr typeSystem) :
 {
 }
 
+OslShaderGenerator::OslShaderGenerator(TypeSystemPtr typeSystem, OslSyntaxPtr syntax) :
+    ShaderGenerator(typeSystem, syntax)
+{
+}
+
+ShaderGeneratorPtr OslShaderGenerator::create(TypeSystemPtr typeSystem, OslSyntaxPtr syntax)
+{
+    if (!typeSystem)
+        typeSystem = TypeSystem::create();
+    if (!syntax)
+        syntax = std::static_pointer_cast<OslSyntax>(OslSyntax::create(typeSystem));
+
+    return std::make_shared<OslShaderGenerator>(typeSystem, syntax);
+}
+
 ShaderPtr OslShaderGenerator::generate(const string& name, ElementPtr element, GenContext& context) const
 {
     ShaderPtr shader = createShader(name, element, context);
@@ -37,7 +52,7 @@ ShaderPtr OslShaderGenerator::generate(const string& name, ElementPtr element, G
 
     if (context.getOptions().oslConnectCiWrapper)
     {
-        addSetCiTerminalNode(graph, element->getDocument(), context);
+        addSetCiTerminalNode(graph, element->getDocument(), getTypeSystem(), context);
     }
 
     ShaderStage& stage = shader->getStage(Stage::PIXEL);
@@ -145,7 +160,7 @@ ShaderPtr OslShaderGenerator::generate(const string& name, ElementPtr element, G
         if (input->getType() == Type::FILENAME)
         {
             // Construct the textureresource variable.
-            const string newVariableName = input->getVariable() + "_";
+            const string newVariableName = input->getVariable() + "_resource";
             const string& type = _syntax->getTypeName(input->getType());
             emitLine(type + newVariableName + " = {" + input->getVariable() + ", " + input->getVariable() + "_colorspace}", stage);
 
@@ -470,8 +485,7 @@ void OslShaderGenerator::emitMetadata(const ShaderPort* port, ShaderStage& stage
     }
 }
 
-
-void OslShaderGenerator::addSetCiTerminalNode(ShaderGraph& graph, ConstDocumentPtr document, GenContext& context) const
+void OslShaderGenerator::addSetCiTerminalNode(ShaderGraph& graph, ConstDocumentPtr document, TypeSystemPtr typeSystem, GenContext& context)
 {
     string setCiNodeDefName = "ND_osl_set_ci";
     NodeDefPtr setCiNodeDef = document->getNodeDef(setCiNodeDefName);
@@ -483,7 +497,7 @@ void OslShaderGenerator::addSetCiTerminalNode(ShaderGraph& graph, ConstDocumentP
         string inputName = input->getName();
         if (stringStartsWith(inputName, "input_"))
         {
-            TypeDesc inputType = _typeSystem->getType(input->getType());
+            TypeDesc inputType = typeSystem->getType(input->getType());
             outputModeMap[inputType] = std::make_shared<TypedValue<int>>(index++);
         }
     }
@@ -501,7 +515,6 @@ void OslShaderGenerator::addSetCiTerminalNode(ShaderGraph& graph, ConstDocumentP
     }
 }
 
-
 namespace OSL
 {
 
diff --git a/source/MaterialXGenOsl/OslShaderGenerator.h b/source/MaterialXGenOsl/OslShaderGenerator.h
index b7a7e7a2cc..c64542d9fc 100644
--- a/source/MaterialXGenOsl/OslShaderGenerator.h
+++ b/source/MaterialXGenOsl/OslShaderGenerator.h
@@ -15,6 +15,9 @@
 
 MATERIALX_NAMESPACE_BEGIN
 
+class OslSyntax;
+using OslSyntaxPtr = shared_ptr<OslSyntax>;
+
 using OslShaderGeneratorPtr = shared_ptr<class OslShaderGenerator>;
 
 /// @class OslShaderGenerator
@@ -25,16 +28,17 @@ class MX_GENOSL_API OslShaderGenerator : public ShaderGenerator
   public:
     /// Constructor.
     OslShaderGenerator(TypeSystemPtr typeSystem);
+    OslShaderGenerator(TypeSystemPtr typeSystem, OslSyntaxPtr syntax);
 
     /// Creator function.
     /// If a TypeSystem is not provided it will be created internally.
     /// Optionally pass in an externally created TypeSystem here,
     /// if you want to keep type descriptions alive after the lifetime
     /// of the shader generator.
-    static ShaderGeneratorPtr create(TypeSystemPtr typeSystem = nullptr)
-    {
-        return std::make_shared<OslShaderGenerator>(typeSystem ? typeSystem : TypeSystem::create());
-    }
+    /// If a OslSyntax is not provided it will be created internally.
+    /// Optionally pass in an externally created OslSyntax here,
+    /// if you want to modify the syntax object before code generation.
+    static ShaderGeneratorPtr create(TypeSystemPtr typeSystem = nullptr, OslSyntaxPtr syntax = nullptr);
 
     /// Return a unique identifier for the target this generator is for
     const string& getTarget() const override { return TARGET; }
@@ -52,6 +56,8 @@ class MX_GENOSL_API OslShaderGenerator : public ShaderGenerator
     /// Register metadata that should be exported to the generated shaders.
     void registerShaderMetadata(const DocumentPtr& doc, GenContext& context) const override;
 
+    static void addSetCiTerminalNode(ShaderGraph& graph, ConstDocumentPtr document, TypeSystemPtr typeSystem, GenContext& context);
+
   protected:
     /// Create and initialize a new OSL shader for shader generation.
     virtual ShaderPtr createShader(const string& name, ElementPtr element, GenContext& context) const;
@@ -67,8 +73,6 @@ class MX_GENOSL_API OslShaderGenerator : public ShaderGenerator
 
     /// Emit metadata for a shader parameter.
     virtual void emitMetadata(const ShaderPort* port, ShaderStage& stage) const;
-
-    void addSetCiTerminalNode(ShaderGraph& graph, ConstDocumentPtr document, GenContext& context) const;
 };
 
 namespace OSL
diff --git a/source/MaterialXGenShader/GenContext.h b/source/MaterialXGenShader/GenContext.h
index 0e5e87804b..e5900597b1 100644
--- a/source/MaterialXGenShader/GenContext.h
+++ b/source/MaterialXGenShader/GenContext.h
@@ -70,6 +70,13 @@ class MX_GENSHADER_API GenContext
         _sourceCodeSearchPath.append(path);
     }
 
+    /// Return the search path used for finding source code during
+    /// code generation
+    const FileSearchPath& getSourceCodeSearchPath() const
+    {
+        return _sourceCodeSearchPath;
+    }
+
     /// Resolve a source code filename, first checking the given local path
     /// then checking any file paths registered by the user.
     FilePath resolveSourceFile(const FilePath& filename, const FilePath& localPath) const
diff --git a/source/MaterialXGenShader/GenOptions.h b/source/MaterialXGenShader/GenOptions.h
index 034ab782c3..5307c46964 100644
--- a/source/MaterialXGenShader/GenOptions.h
+++ b/source/MaterialXGenShader/GenOptions.h
@@ -97,7 +97,8 @@ class MX_GENSHADER_API GenOptions
         hwWriteEnvPrefilter(false),
         hwImplicitBitangents(true),
         oslImplicitSurfaceShaderConversion(true),
-        oslConnectCiWrapper(false)
+        oslConnectCiWrapper(false),
+        oslTempOsoPath("")
     {
     }
     virtual ~GenOptions() { }
@@ -212,6 +213,9 @@ class MX_GENSHADER_API GenOptions
     // for OSL targets.
     // Defaults to false.
     bool oslConnectCiWrapper;
+
+    // Directory used to write temporary oso files to.
+    FilePath oslTempOsoPath;
 };
 
 MATERIALX_NAMESPACE_END
diff --git a/source/MaterialXGenShader/ShaderGenerator.cpp b/source/MaterialXGenShader/ShaderGenerator.cpp
index 9dc2d5f212..d7486c7ead 100644
--- a/source/MaterialXGenShader/ShaderGenerator.cpp
+++ b/source/MaterialXGenShader/ShaderGenerator.cpp
@@ -340,6 +340,8 @@ ShaderNodeImplPtr ShaderGenerator::getImplementation(const NodeDef& nodedef, Gen
 
     impl->initialize(*implElement, context);
 
+    addPortImplementationNames(implElement, *impl);
+
     // Cache it.
     context.addNodeImplementation(name, impl);
 
@@ -410,7 +412,7 @@ void ShaderGenerator::registerTypeDefs(const DocumentPtr& doc)
             typeAlias,
             typeDefinition);
 
-        _syntax->registerTypeSyntax(typeDesc, structTypeSyntax);
+        _syntax->registerTypeSyntax(typeDesc, structTypeSyntax, true);
     }
 }
 
diff --git a/source/MaterialXGenShader/ShaderGenerator.h b/source/MaterialXGenShader/ShaderGenerator.h
index ce6c3cf996..3e60a18e2c 100644
--- a/source/MaterialXGenShader/ShaderGenerator.h
+++ b/source/MaterialXGenShader/ShaderGenerator.h
@@ -265,6 +265,29 @@ class MX_GENSHADER_API ShaderGenerator
     friend ShaderGraph;
 };
 
+template <typename T>
+void addPortImplementationNames(ConstInterfaceElementPtr implElement, T& dest)
+{
+    if (implElement)
+    {
+        for (const auto& port : implElement->getActiveInputs())
+        {
+            if (port->hasImplementationName())
+            {
+                dest.addPortImplName(port->getName(), port->getImplementationName());
+            }
+        }
+
+        for (const auto& port : implElement->getActiveOutputs())
+        {
+            if (port->hasImplementationName())
+            {
+                dest.addPortImplName(port->getName(), port->getImplementationName());
+            }
+        }
+    }
+}
+
 MATERIALX_NAMESPACE_END
 
 #endif // MATERIALX_SHADERGENERATOR_H
diff --git a/source/MaterialXGenShader/ShaderGraph.cpp b/source/MaterialXGenShader/ShaderGraph.cpp
index 1fd0600b6b..4d0505fefc 100644
--- a/source/MaterialXGenShader/ShaderGraph.cpp
+++ b/source/MaterialXGenShader/ShaderGraph.cpp
@@ -8,6 +8,7 @@
 #include <MaterialXGenShader/Exception.h>
 #include <MaterialXGenShader/GenContext.h>
 #include <MaterialXGenShader/Util.h>
+#include <MaterialXGenShader/Nodes/CompoundNode.h>
 
 #include <iostream>
 #include <queue>
@@ -629,6 +630,57 @@ ShaderGraphPtr ShaderGraph::create(const ShaderGraph* parent, const string& name
         // Set root for upstream dependency traversal
         root = node;
     }
+    else if (element->isA<NodeDef>())
+    {
+        NodeDefPtr nodeDef = element->asA<NodeDef>();
+
+        graph = std::make_shared<ShaderGraph>(parent, name, element->getDocument());
+
+        // Create input sockets
+        graph->addInputSockets(*nodeDef, context);
+
+        // Create output sockets
+        graph->addOutputSockets(*nodeDef, context);
+
+        // Create this shader node in the graph.
+        ShaderNodePtr newNode = ShaderNode::create(graph.get(), name, *nodeDef, context);
+        graph->addNode(newNode);
+
+        // Share metadata.
+        graph->setMetadata(newNode->getMetadata());
+
+        // Connect it to the graph outputs
+        for (size_t i = 0; i < newNode->numOutputs(); ++i)
+        {
+            ShaderGraphOutputSocket* outputSocket = graph->getOutputSocket(i);
+            outputSocket->makeConnection(newNode->getOutput(i));
+        }
+
+        // Handle node input ports
+        for (const InputPtr& nodedefInput : nodeDef->getActiveInputs())
+        {
+            ShaderGraphInputSocket* inputSocket = graph->getInputSocket(nodedefInput->getName());
+            ShaderInput* input = newNode->getInput(nodedefInput->getName());
+            if (!inputSocket || !input)
+            {
+                throw ExceptionShaderGenError("Node input '" + nodedefInput->getName() + "' doesn't match an existing input on graph '" + graph->getName() + "'");
+            }
+
+            input->setBindInput();
+
+            // Connect graph socket to the node input
+            inputSocket->makeConnection(input);
+
+            // Share metadata.
+            inputSocket->setMetadata(input->getMetadata());
+        }
+
+        ImplementationPtr implElement = nodeDef->getImplementation(context.getShaderGenerator().getTarget())->asA<Implementation>();
+        addPortImplementationNames(implElement, *graph);
+
+        // NodeDef generation has no traversal
+        root = nullptr;
+    }
 
     if (!graph)
     {
@@ -856,6 +908,18 @@ void ShaderGraph::addNode(ShaderNodePtr node)
     _nodeOrder.push_back(node.get());
 }
 
+void ShaderGraph::removeNode(const string& name)
+{
+    ShaderNodePtr nodePtr = _nodeMap[name];
+    if (nodePtr)
+    {
+        disconnect(nodePtr.get());
+        _nodeMap.erase(name);
+        auto it = std::find(_nodeOrder.begin(), _nodeOrder.end(), nodePtr.get());
+        _nodeOrder.erase(it);
+    }
+}
+
 ShaderNode* ShaderGraph::getNode(const string& name)
 {
     auto it = _nodeMap.find(name);
@@ -1162,25 +1226,25 @@ void ShaderGraph::setVariableNames(GenContext& context)
 
     for (ShaderGraphInputSocket* inputSocket : getInputSockets())
     {
-        const string variable = syntax.getVariableName(inputSocket->getName(), inputSocket->getType(), _identifiers);
+        const string variable = syntax.getVariableName(getPortName(inputSocket->getName()), inputSocket->getType(), _identifiers);
         inputSocket->setVariable(variable);
     }
     for (ShaderGraphOutputSocket* outputSocket : getOutputSockets())
     {
-        const string variable = syntax.getVariableName(outputSocket->getName(), outputSocket->getType(), _identifiers);
+        const string variable = syntax.getVariableName(getPortName(outputSocket->getName()), outputSocket->getType(), _identifiers);
         outputSocket->setVariable(variable);
     }
     for (ShaderNode* node : getNodes())
     {
         for (ShaderInput* input : node->getInputs())
         {
-            string variable = input->getFullName();
+            string variable = node->getName() + "_" + node->getPortName(input->getName());
             variable = syntax.getVariableName(variable, input->getType(), _identifiers);
             input->setVariable(variable);
         }
         for (ShaderOutput* output : node->getOutputs())
         {
-            string variable = output->getFullName();
+            string variable = node->getName() + "_" + node->getPortName(output->getName());
             variable = syntax.getVariableName(variable, output->getType(), _identifiers);
             output->setVariable(variable);
         }
@@ -1287,6 +1351,219 @@ void ShaderGraph::populateUnitTransformMap(UnitSystemPtr unitSystem, ShaderPort*
     }
 }
 
+void ShaderGraph::flattenGraph()
+{
+    bool foundCompoundNode = true;
+    // Use a while loop to handle the nested compound nodes
+    while (foundCompoundNode)
+    {
+        foundCompoundNode = false;
+        vector<ShaderNode*> nodes = getNodes();
+        for (ShaderNode* node : nodes)
+        {
+            if (!node)
+                continue;
+
+            const ShaderNodeImpl& impl = node->getImplementation();
+            const CompoundNode* compoundNodeImpl = dynamic_cast<const CompoundNode*>(&impl);
+            if (!compoundNodeImpl)
+                continue;
+
+            expandCompoundNode(node, compoundNodeImpl);
+            foundCompoundNode = true;
+        }
+    }
+}
+
+void ShaderGraph::expandCompoundNode(ShaderNode* parentNode, const CompoundNode* compoundNodeImpl)
+{
+    string parentNodeName = parentNode->getName();
+
+    auto getNewNodeName = [parentNodeName](const ShaderNode* node) -> string
+    {
+        return parentNodeName + "_" + node->getName();
+    };
+
+    ShaderGraph* compoundGraph = compoundNodeImpl->getGraph();
+
+    // Initially just create copies of each of the nodes inside the compound graph with
+    // a prefixed name and copy all the non-connection data.
+    for (ShaderNode* node : compoundGraph->getNodes())
+    {
+        ShaderNodePtr newNode = ShaderNode::create(this, getNewNodeName(node), node->getImplementationPtr(), node->getClassification());
+        addNode(newNode);
+
+        for (const ShaderInput* port : node->getInputs())
+        {
+            ShaderInput* newPort = newNode->addInput(port->getName(), port->getType());
+            port->copyToPort(newPort);
+        }
+
+        for (const ShaderOutput* port : node->getOutputs())
+        {
+            ShaderOutput* newPort = newNode->addOutput(port->getName(), port->getType());
+            port->copyToPort(newPort);
+        }
+    }
+
+    // Loop all the newly created nodes and build all necessary connections, or data from the exterior ports.
+    for (ShaderNode* node : compoundGraph->getNodes())
+    {
+        ShaderNode* newNode = getNode(getNewNodeName(node));
+
+        for (const ShaderInput* port : node->getInputs())
+        {
+            const ShaderOutput* upstreamConnection = port->getConnection();
+            if (!upstreamConnection)
+                continue;
+
+            ShaderInput* newDownstreamInput = newNode->getInput(port->getName());
+            if (!newDownstreamInput)
+            {
+                throw ExceptionShaderGenError("Could not find expected input port on new node '"+port->getName()+"'");
+            }
+
+            const ShaderNode* upstreamConnectedNode = upstreamConnection->getNode();
+
+            if (upstreamConnectedNode != compoundGraph)
+            {
+                // Connect to another node inside the graph
+                // NOTE : we handle connections to the compoundGraph later when we
+                // loop the input sockets.
+                string newUpstreamConnectedNodeName = getNewNodeName(upstreamConnectedNode);
+                ShaderNode* newUpstreamConnectedNode = getNode(newUpstreamConnectedNodeName);
+                if (!newUpstreamConnectedNode)
+                {
+                    throw ExceptionShaderGenError("Could not find expected upstream connected node '"+newUpstreamConnectedNodeName+"'");
+                }
+
+                ShaderOutput* newUpstreamConnectedOutput = newUpstreamConnectedNode->getOutput(upstreamConnection->getName());
+                if (!newUpstreamConnectedOutput)
+                {
+                    throw ExceptionShaderGenError("Could not find expected upstream output '"+newUpstreamConnectedNodeName+"."+upstreamConnection->getName()+"'");
+                }
+
+                newDownstreamInput->makeConnection(newUpstreamConnectedOutput);
+            }
+        }
+    }
+
+    for (ShaderGraphInputSocket* inputSocket : compoundGraph->getInputSockets())
+    {
+        ShaderInputVec downstreamConnections = inputSocket->getConnections();
+        if (downstreamConnections.empty())
+            continue;
+
+        ShaderInput* parentNodeInput = parentNode->getInput(inputSocket->getName());
+        if (!parentNodeInput)
+        {
+            throw ExceptionShaderGenError("Could not find expected input port '"+parentNodeName+"."+inputSocket->getName()+"'");
+        }
+
+        ShaderOutput* upstreamConnectedOutput = parentNodeInput->getConnection();
+        if (!upstreamConnectedOutput)
+        {
+            // If we have no upstream incoming connection then we have to copy the value
+            // to all the downstream internal connected inputs
+            for (const ShaderInput* downstreamConnection : downstreamConnections)
+            {
+                const ShaderNode* downstreamConnectedNode = downstreamConnection->getNode();
+                string newDownstreamConnectedNodeName = getNewNodeName(downstreamConnectedNode);
+
+                ShaderNode* newDownstreamNode = getNode(newDownstreamConnectedNodeName);
+                if (!newDownstreamNode)
+                {
+                    throw ExceptionShaderGenError("Could not find expected downstream node '"+newDownstreamConnectedNodeName+"'");
+                }
+
+                ShaderInput* newDownstreamInput = newDownstreamNode->getInput(downstreamConnection->getName());
+                if (!newDownstreamInput)
+                {
+                    throw ExceptionShaderGenError("Could not find expected downstream input '"+newDownstreamConnectedNodeName+"."+downstreamConnection->getName()+"'");
+                }
+
+                newDownstreamInput->setValue(parentNodeInput->getValue());
+            }
+        }
+        else
+        {
+            // connect the upstream output port to each of the downstream internal
+            // connected inputs
+            for (const ShaderInput* downstreamConnection : downstreamConnections)
+            {
+                const ShaderNode* downstreamNode = downstreamConnection->getNode();
+                string newDownstreamConnectedNodeName = getNewNodeName(downstreamNode);
+
+                ShaderNode* newDownstreamNode = getNode(newDownstreamConnectedNodeName);
+                if (!newDownstreamNode)
+                {
+                    throw ExceptionShaderGenError("Could not find expected downstream node '"+newDownstreamConnectedNodeName+"'");
+                }
+                ShaderInput* newDownstreamInput = newDownstreamNode->getInput(downstreamConnection->getName());
+                if (!newDownstreamInput)
+                {
+                    throw ExceptionShaderGenError("Could not find expected downstream input '"+newDownstreamConnectedNodeName+"."+downstreamConnection->getName()+"'");
+                }
+
+                newDownstreamInput->makeConnection(upstreamConnectedOutput);
+            }
+
+            // finally we remove the prior connection
+            upstreamConnectedOutput->breakConnection(parentNodeInput);
+        }
+    }
+
+    for (ShaderGraphOutputSocket* outputSocket : compoundGraph->getOutputSockets())
+    {
+        ShaderOutput* upstreamConnection = outputSocket->getConnection();
+        if (!upstreamConnection)
+            continue;
+
+        ShaderNode* upstreamConnectedNode = upstreamConnection->getNode();
+        string newUpstreamConnectedNodeName = getNewNodeName(upstreamConnectedNode);
+
+        ShaderNode* newUpstreamNode = getNode(newUpstreamConnectedNodeName);
+        if (!newUpstreamNode)
+        {
+            throw ExceptionShaderGenError("Could not find expected upstream node '"+newUpstreamConnectedNodeName+"'");
+        }
+        ShaderOutput* newUpstreamOutput = newUpstreamNode->getOutput(upstreamConnection->getName());
+        if (!newUpstreamOutput)
+        {
+            throw ExceptionShaderGenError("Could not find expected upstream output '"+newUpstreamConnectedNodeName+"."+upstreamConnection->getName()+"'");
+        }
+
+        ShaderOutput* parentNodeOutput = parentNode->getOutput(outputSocket->getName());
+        if (!parentNodeOutput)
+        {
+            throw ExceptionShaderGenError("Could not find expected output port '"+parentNodeName+"."+outputSocket->getName()+"'");
+        }
+
+        // Loop all downstream connected inputs and connect to the corresponding output on the newly created nodes
+        ShaderInputVec downstreamConnectedInputs = parentNodeOutput->getConnections();
+        for (ShaderInput* downstreamConnectedInput : downstreamConnectedInputs)
+        {
+            downstreamConnectedInput->makeConnection(newUpstreamOutput);
+        }
+    }
+
+    removeNode(parentNodeName);
+}
+
+void ShaderGraph::addPortImplName(const string& portName, const string& implName)
+{
+    _portImplNames[portName] = implName;
+}
+
+const string& ShaderGraph::getPortName(const string& portName) const
+{
+    if (_impl)
+        return _impl->getPortName(portName);
+
+    auto it = _portImplNames.find(portName);
+    return it != _portImplNames.end() ? it->second : portName;
+}
+
 namespace
 {
 static const ShaderGraphEdgeIterator NULL_EDGE_ITERATOR(nullptr);
diff --git a/source/MaterialXGenShader/ShaderGraph.h b/source/MaterialXGenShader/ShaderGraph.h
index dfa215e27f..5f25dcbe34 100644
--- a/source/MaterialXGenShader/ShaderGraph.h
+++ b/source/MaterialXGenShader/ShaderGraph.h
@@ -26,6 +26,7 @@ class Syntax;
 class ShaderGraphEdge;
 class ShaderGraphEdgeIterator;
 class GenOptions;
+class CompoundNode;
 
 /// An internal input socket in a shader graph,
 /// used for connecting internal nodes to the outside
@@ -125,6 +126,13 @@ class MX_GENSHADER_API ShaderGraph : public ShaderNode
     /// Return the map of unique identifiers used in the scope of this graph.
     IdentifierMap& getIdentifierMap() { return _identifiers; }
 
+    /// Inplace expands all Compound nodes, which can be created by nodegraph
+    /// elements in the document or nodes that use a nodegraph implementation
+    void flattenGraph();
+
+    void addPortImplName(const string& portName, const string& implName);
+    const string& getPortName(const string& portName) const override;
+
   protected:
     /// Create node connections corresponding to the connection between a pair of elements.
     /// @param downstreamElement Element representing the node to connect to.
@@ -144,6 +152,9 @@ class MX_GENSHADER_API ShaderGraph : public ShaderNode
     /// Add a node to the graph
     void addNode(ShaderNodePtr node);
 
+    /// Remove a node from the graph by name
+    void removeNode(const string& name);
+
     /// Add input sockets from an interface element (nodedef, nodegraph or node)
     void addInputSockets(const InterfaceElement& elem, GenContext& context);
 
@@ -195,6 +206,12 @@ class MX_GENSHADER_API ShaderGraph : public ShaderNode
     /// Break all connections on a node
     void disconnect(ShaderNode* node) const;
 
+private:
+    void expandCompoundNode(ShaderNode* shaderNode, const CompoundNode* compoundNodeImpl);
+
+    // This "protected" should probably be "private" - this change compiles fine for the MaterialX codebase
+    // but would change possible downstream use of the class outside the project.
+protected:
     ConstDocumentPtr _document;
     std::unordered_map<string, ShaderNodePtr> _nodeMap;
     std::vector<ShaderNode*> _nodeOrder;
@@ -209,6 +226,9 @@ class MX_GENSHADER_API ShaderGraph : public ShaderNode
     std::vector<std::pair<ShaderOutput*, ColorSpaceTransform>> _outputColorTransformMap;
     // Temporary storage for outputs that require unit transformations
     std::vector<std::pair<ShaderOutput*, UnitTransform>> _outputUnitTransformMap;
+
+private:
+    std::unordered_map<string, string> _portImplNames;
 };
 
 /// @class ShaderGraphEdge
diff --git a/source/MaterialXGenShader/ShaderNode.cpp b/source/MaterialXGenShader/ShaderNode.cpp
index 76f8e56ab2..aac27da148 100644
--- a/source/MaterialXGenShader/ShaderNode.cpp
+++ b/source/MaterialXGenShader/ShaderNode.cpp
@@ -37,6 +37,18 @@ string ShaderPort::getValueString() const
     return getValue() ? getValue()->getValueString() : EMPTY_STRING;
 }
 
+void ShaderPort::copyToPort(ShaderPort* to) const
+{
+    to->setPath(getPath());
+    to->setSemantic(getSemantic());
+    to->setValue(getValue());
+    to->setUnit(getUnit());
+    to->setColorSpace(getColorSpace());
+    to->setGeomProp(getGeomProp());
+    to->setMetadata(getMetadata());
+    to->setFlags(getFlags());
+}
+
 //
 // ShaderInput methods
 //
@@ -541,4 +553,9 @@ ShaderOutput* ShaderNode::addOutput(const string& name, TypeDesc type)
     return output.get();
 }
 
+const string& ShaderNode::getPortName(const string& portName) const
+{
+    return _impl ? _impl->getPortName(portName) : portName;
+}
+
 MATERIALX_NAMESPACE_END
diff --git a/source/MaterialXGenShader/ShaderNode.h b/source/MaterialXGenShader/ShaderNode.h
index b8cd3a9acc..94b2d4e0a1 100644
--- a/source/MaterialXGenShader/ShaderNode.h
+++ b/source/MaterialXGenShader/ShaderNode.h
@@ -251,6 +251,9 @@ class MX_GENSHADER_API ShaderPort : public std::enable_shared_from_this<ShaderPo
     /// Get the metadata vector.
     const ShaderMetadataVecPtr& getMetadata() const { return _metadata; }
 
+    /// Copy all the local data to the target port.
+    void copyToPort(ShaderPort* to) const;
+
   protected:
     ShaderNode* _node;
     TypeDesc _type;
@@ -435,6 +438,10 @@ class MX_GENSHADER_API ShaderNode
     {
         return *_impl;
     }
+    ShaderNodeImplPtr getImplementationPtr() const
+    {
+        return _impl;
+    }
 
     /// Initialize this shader node with all required data
     /// from the given node and nodedef.
@@ -489,6 +496,8 @@ class MX_GENSHADER_API ShaderNode
         return (!_impl || _impl->isEditable(input));
     }
 
+    virtual const string& getPortName(const string& portName) const;
+
   protected:
     /// Create metadata from the nodedef according to registered metadata.
     void createMetadata(const NodeDef& nodeDef, GenContext& context);
diff --git a/source/MaterialXGenShader/ShaderNodeImpl.cpp b/source/MaterialXGenShader/ShaderNodeImpl.cpp
index 918e704ca0..6e6cb95dea 100644
--- a/source/MaterialXGenShader/ShaderNodeImpl.cpp
+++ b/source/MaterialXGenShader/ShaderNodeImpl.cpp
@@ -34,6 +34,17 @@ void ShaderNodeImpl::initialize(const InterfaceElement& element, GenContext&)
     _hash = std::hash<string>{}(_name);
 }
 
+void ShaderNodeImpl::addPortImplName(const string& portName, const string& implName)
+{
+    _portImplNames[portName] = implName;
+}
+
+const string& ShaderNodeImpl::getPortName(const string& portName) const
+{
+    auto it = _portImplNames.find(portName);
+    return it != _portImplNames.end() ? it->second : portName;
+}
+
 void ShaderNodeImpl::addInputs(ShaderNode&, GenContext&) const
 {
 }
diff --git a/source/MaterialXGenShader/ShaderNodeImpl.h b/source/MaterialXGenShader/ShaderNodeImpl.h
index 1a365a2862..c18b85da27 100644
--- a/source/MaterialXGenShader/ShaderNodeImpl.h
+++ b/source/MaterialXGenShader/ShaderNodeImpl.h
@@ -97,6 +97,9 @@ class MX_GENSHADER_API ShaderNodeImpl
         return true;
     }
 
+    void addPortImplName(const string& portName, const string& implName);
+    const string& getPortName(const string& portName) const;
+
   protected:
     /// Protected constructor
     ShaderNodeImpl();
@@ -109,6 +112,9 @@ class MX_GENSHADER_API ShaderNodeImpl
   protected:
     string _name;
     size_t _hash;
+
+  private:
+    std::unordered_map<string, string> _portImplNames;
 };
 
 /// A no operation node, to be used for organizational nodes that has no code to execute.
diff --git a/source/MaterialXGenShader/Syntax.cpp b/source/MaterialXGenShader/Syntax.cpp
index f33a24fd30..eb6d7a6026 100644
--- a/source/MaterialXGenShader/Syntax.cpp
+++ b/source/MaterialXGenShader/Syntax.cpp
@@ -39,7 +39,7 @@ Syntax::Syntax(TypeSystemPtr typeSystem) :
 {
 }
 
-void Syntax::registerTypeSyntax(TypeDesc type, TypeSyntaxPtr syntax)
+void Syntax::registerTypeSyntax(TypeDesc type, TypeSyntaxPtr syntax, bool isCustomSyntax)
 {
     auto it = _typeSyntaxIndexByType.find(type);
     if (it != _typeSyntaxIndexByType.end())
@@ -49,6 +49,10 @@ void Syntax::registerTypeSyntax(TypeDesc type, TypeSyntaxPtr syntax)
     else
     {
         _typeSyntaxes.push_back(syntax);
+        if (isCustomSyntax)
+        {
+            _customTypeSyntaxes.push_back({type,syntax});
+        }
         _typeSyntaxIndexByType[type] = _typeSyntaxes.size() - 1;
     }
 
diff --git a/source/MaterialXGenShader/Syntax.h b/source/MaterialXGenShader/Syntax.h
index 3d580f9300..aa7d450f95 100644
--- a/source/MaterialXGenShader/Syntax.h
+++ b/source/MaterialXGenShader/Syntax.h
@@ -57,7 +57,7 @@ class MX_GENSHADER_API Syntax
 
     /// Register syntax handling for a data type.
     /// Required to be set for all supported data types.
-    void registerTypeSyntax(TypeDesc type, TypeSyntaxPtr syntax);
+    void registerTypeSyntax(TypeDesc type, TypeSyntaxPtr syntax, bool isCustomSyntax=false);
     [[deprecated]] void registerTypeSyntax(const TypeDesc* type, TypeSyntaxPtr syntax) { registerTypeSyntax(*type, syntax); }
 
     /// Register names that are reserved words not to be used by a code generator when naming
@@ -84,6 +84,9 @@ class MX_GENSHADER_API Syntax
     /// Returns an array of all registered type syntax objects
     const vector<TypeSyntaxPtr>& getTypeSyntaxes() const { return _typeSyntaxes; }
 
+    /// Returns an array of all the custom type syntaxes registered and their corresponding TypeDesc objects
+    const vector<std::pair<TypeDesc,TypeSyntaxPtr>>& getCustomTypeSyntaxes() const { return _customTypeSyntaxes; }
+
     /// Return a type description for the given type name.
     TypeDesc getType(const string& name) const { return _typeSystem->getType(name); }
 
@@ -212,6 +215,7 @@ class MX_GENSHADER_API Syntax
 
     TypeSystemPtr _typeSystem;
     vector<TypeSyntaxPtr> _typeSyntaxes;
+    vector<std::pair<TypeDesc,TypeSyntaxPtr>> _customTypeSyntaxes;
     std::unordered_map<TypeDesc, size_t, TypeDesc::Hasher> _typeSyntaxIndexByType;
 
     StringSet _reservedWords;
diff --git a/source/MaterialXTest/MaterialXRenderOsl/RenderOsl.cpp b/source/MaterialXTest/MaterialXRenderOsl/RenderOsl.cpp
index 42ab9aee9c..cf2a8c0d00 100644
--- a/source/MaterialXTest/MaterialXRenderOsl/RenderOsl.cpp
+++ b/source/MaterialXTest/MaterialXRenderOsl/RenderOsl.cpp
@@ -13,6 +13,7 @@
 #include <MaterialXRender/OiioImageLoader.h>
 #endif
 
+#include <MaterialXGenOsl/Nodes/OsoNode.h>
 #include <MaterialXGenOsl/OslShaderGenerator.h>
 #include <MaterialXGenOsl/OslNetworkShaderGenerator.h>
 
@@ -72,6 +73,30 @@ class BitangentOsl : public mx::ShaderNodeImpl
     }
 };
 
+class TangentOslNetwork : public mx::OsoNode
+{
+public:
+    TangentOslNetwork() : OsoNode("IM_tangent_vector3_genoslnetwork_test","")
+    {}
+
+    static mx::ShaderNodeImplPtr create()
+    {
+        return std::make_shared<TangentOslNetwork>();
+    }
+};
+
+class BitangentOslNetwork : public mx::OsoNode
+{
+public:
+    BitangentOslNetwork() : OsoNode("IM_bitangent_vector3_genoslnetwork_test","")
+    {}
+
+    static mx::ShaderNodeImplPtr create()
+    {
+        return std::make_shared<BitangentOslNetwork>();
+    }
+};
+
 } // anonymous namespace
 
 class OslShaderRenderTester : public RenderUtil::ShaderRenderTester
@@ -106,20 +131,7 @@ class OslShaderRenderTester : public RenderUtil::ShaderRenderTester
     void addSkipFiles() override
     {
         _skipFiles.insert("standard_surface_onyx_hextiled.mtlx");
-        if (_useOslCmdStr)
-        {
-            _skipFiles.insert("hextiled.mtlx");
-            _skipFiles.insert("filename_cm_test.mtlx");
-            _skipFiles.insert("shader_ops.mtlx");
-            _skipFiles.insert("chiang_hair_surfaceshader.mtlx");
-            _skipFiles.insert("network_surfaceshader.mtlx");
-            _skipFiles.insert("sheen.mtlx");
-            _skipFiles.insert("toon_shade.mtlx");
-            _skipFiles.insert("bsdf_graph.mtlx");
-            _skipFiles.insert("varying_ior.mtlx");
-            _skipFiles.insert("vertical_layering.mtlx");
-            _skipFiles.insert("mix_bsdf.mtlx");
-        }
+        _skipFiles.insert("hextiled.mtlx");
     }
 
     bool saveImage(const mx::FilePath& filePath, mx::ConstImagePtr image, bool /*verticalFlip*/) const override
@@ -203,7 +215,7 @@ bool OslShaderRenderTester::runRenderer(const std::string& shaderName,
                                          std::ostream& log,
                                          const GenShaderUtil::TestSuiteOptions& testOptions,
                                          RenderUtil::RenderProfileTimes& profileTimes,
-                                         const mx::FileSearchPath&,
+                                         const mx::FileSearchPath& searchPath,
                                          const std::string& outputPath,
                                          mx::ImageVec* imageVec)
 {
@@ -233,9 +245,18 @@ bool OslShaderRenderTester::runRenderer(const std::string& shaderName,
                 contextOptions.targetColorSpaceOverride = "lin_rec709";
                 contextOptions.oslConnectCiWrapper = true;
 
-                // Apply local overrides for shader generation.
-                shadergen.registerImplementation("IM_tangent_vector3_" + mx::OslShaderGenerator::TARGET, TangentOsl::create);
-                shadergen.registerImplementation("IM_bitangent_vector3_" + mx::OslShaderGenerator::TARGET, BitangentOsl::create);
+                if (_useOslCmdStr)
+                {
+                    // Apply local overrides for shader generation.
+                    shadergen.registerImplementation("IM_tangent_vector3_" + mx::OslNetworkShaderGenerator::TARGET, TangentOslNetwork::create);
+                    shadergen.registerImplementation("IM_bitangent_vector3_" + mx::OslNetworkShaderGenerator::TARGET, BitangentOslNetwork::create);
+                }
+                else
+                {
+                    // Apply local overrides for shader generation.
+                    shadergen.registerImplementation("IM_tangent_vector3_" + mx::OslShaderGenerator::TARGET, TangentOsl::create);
+                    shadergen.registerImplementation("IM_bitangent_vector3_" + mx::OslShaderGenerator::TARGET, BitangentOsl::create);
+                }
 
                 shader = shadergen.generate(shaderName, element, context);
             }
@@ -254,6 +275,12 @@ bool OslShaderRenderTester::runRenderer(const std::string& shaderName,
 
             std::string oslCmdStr = shader->getSourceCode();
 
+            // Because we're embedding the command string inside the XML scene template we need
+            // to replace any invalid characters.
+            const mx::StringMap xmlReplaceMapping = { { "<", "&lt;" }, { ">", "&gt;" } };
+            oslCmdStr = mx::replaceSubstrings(oslCmdStr, xmlReplaceMapping);
+
+
             std::string shaderPath;
             mx::FilePath outputFilePath = outputPath;
             // Use separate directory for reduced output
@@ -302,9 +329,10 @@ bool OslShaderRenderTester::runRenderer(const std::string& shaderName,
                 const mx::ShaderStage& stage = shader->getStage(mx::Stage::PIXEL);
 
                 // Bind IBL image name overrides.
+                mx::FilePath envmapPath = searchPath.find(mx::FilePath(testOptions.radianceIBLPath));
                 mx::StringVec envOverrides;
                 std::string envmap_filename("string envmap_filename \"");
-                envmap_filename += testOptions.radianceIBLPath;
+                envmap_filename += envmapPath.asString();
                 envmap_filename += "\";\n";
                 envOverrides.push_back(envmap_filename);
 
@@ -334,7 +362,6 @@ bool OslShaderRenderTester::runRenderer(const std::string& shaderName,
                     }
 
                     // Set scene template file. For now we only have the constant color scene file
-                    mx::FileSearchPath searchPath = mx::getDefaultDataSearchPath();
                     mx::FilePath sceneTemplatePath = searchPath.find("resources/Utilities/");
                     sceneTemplatePath = sceneTemplatePath / sceneTemplateFile;
                     _renderer->setOslTestRenderSceneTemplateFile(sceneTemplatePath.asString());
diff --git a/source/MaterialXTest/MaterialXRenderOsl/Utilities/IM_bitangent_vector3_genoslnetwork_test.osl b/source/MaterialXTest/MaterialXRenderOsl/Utilities/IM_bitangent_vector3_genoslnetwork_test.osl
new file mode 100644
index 0000000000..b7789d0930
--- /dev/null
+++ b/source/MaterialXTest/MaterialXRenderOsl/Utilities/IM_bitangent_vector3_genoslnetwork_test.osl
@@ -0,0 +1,9 @@
+shader IM_bitangent_vector3_genoslnetwork_test
+(
+    string space = "object",
+    int index = 0,
+    output vector out = vector(0.0)
+)
+{
+    out = normalize(cross(N, vector(N[2], 0, -N[0])));
+}
diff --git a/source/MaterialXTest/MaterialXRenderOsl/Utilities/IM_tangent_vector3_genoslnetwork_test.osl b/source/MaterialXTest/MaterialXRenderOsl/Utilities/IM_tangent_vector3_genoslnetwork_test.osl
new file mode 100644
index 0000000000..320b10fe99
--- /dev/null
+++ b/source/MaterialXTest/MaterialXRenderOsl/Utilities/IM_tangent_vector3_genoslnetwork_test.osl
@@ -0,0 +1,9 @@
+shader IM_tangent_vector3_genoslnetwork_test
+(
+    string space = "object",
+    int index = 0,
+    output vector out = vector(0.0)
+)
+{
+    out = normalize(vector(N[2], 0, -N[0]));
+}
diff --git a/source/MaterialXTest/MaterialXRenderOsl/Utilities/scene_template_oslcmd.xml b/source/MaterialXTest/MaterialXRenderOsl/Utilities/scene_template_oslcmd.xml
index 4451bb7853..a430390c8b 100644
--- a/source/MaterialXTest/MaterialXRenderOsl/Utilities/scene_template_oslcmd.xml
+++ b/source/MaterialXTest/MaterialXRenderOsl/Utilities/scene_template_oslcmd.xml
@@ -1,6 +1,9 @@
 <!-- Template for a lit scene in testrender -->
 <World>
-   <Camera eye="0, 0, 3" dir="0, 0, -1" fov="79.334" />
+   <!-- The camera FOV is compensated for [-0.5, 0.5] screen coordinates,
+        and matches a 45 degree FOV with [-1, 1] screen coordinates.
+        FOV = atan(2 * tan(45 * PI/360)) * 360/PI = 79.27854 -->
+   <Camera eye="0, 0, 3" dir="0, 0, -1" fov="79.27854" />
 
    <!-- Background environment map. -->
    <ShaderGroup>

From 4a86797d655e57c0f702a9fb5745a2e061287354 Mon Sep 17 00:00:00 2001
From: Lee Kerley <ld_kerley@icloud.com>
Date: Fri, 2 Jan 2026 15:04:58 -0800
Subject: [PATCH 2/2] fix missing include

---
 source/MaterialXFormat/File.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/MaterialXFormat/File.cpp b/source/MaterialXFormat/File.cpp
index c4570c4f79..a8c3fdb070 100644
--- a/source/MaterialXFormat/File.cpp
+++ b/source/MaterialXFormat/File.cpp
@@ -30,7 +30,7 @@
 #include <array>
 #include <cctype>
 #include <cerrno>
-// #include <cstring>
+#include <cstring>
 #include <random>
 #include <filesystem>