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..a8c3fdb070 100644
--- a/source/MaterialXFormat/File.cpp
+++ b/source/MaterialXFormat/File.cpp
@@ -31,6 +31,8 @@
 #include <cctype>
 #include <cerrno>
 #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>