The current DAG system is pretty good, but it's also kinda complicated. I'd like to suggest a slightly more abstract architecture for the renderer here. The core ideas here: The whole target frame is split up into multiple layers, with one layer for each logical partition of the process. So, there would be one layer for basic entities, one for applying textures to entities, one for NUI, etc. Each layer and each Node get ResourceUrn names, namescoped to the module they are in. Each layer also automatically gets two nodes signalling its start and end. Each node lists the Nodes they depend on though ResourceUrns. Each layer consists of it's own DAG, which specifies its render pipeline. All the nodes in a layer share a Context and a FBOManager. They can only access data from other layers explicitly, in the interest of stopping all those weird artifacts from non-deterministic ordering in parallel processing. Each layer outputs to a single buffer. Each Node is invoked with a pointer to this FBO, and it is expected to write to it if it outputs. This helps in writing nodes used in multiple layers, such as tint nodes that could be used in the visual debugger. If a Node wants to access an FBO from another layer, it needs to do so explicitly. For example, if a node in layer A wanted to access a resource in layer B: Block layer A. Wait for the currently running node in layer B to finish. Run the node in A with the FBO, block layer B. Continue as usual. Nevermind all that. We don't need it, at least nnot yet. When all the layers are complete, the buffers are combined to the output. This also has the happy side effect of making it really easy to render in parallel, at least at the layer level. We could also implement isolated sublayers somehow, to extend this for layers with really heavy rendering. We also want to support modules, and here's one way we could do it: Create a GraphManager class to manage Layers and Nodes, and expose some API functions for adding them. Each module consists of a set of Layers(if the module wants to create new ones), and a set of Nodes with a desired Urn for itself(which mentions which layer it's part of) and a list of dependencies. Add these to the graph through the API. I'm not really sure how to inject tasks properly, any suggestions? Changes to current codebase: The nodes would have to be refractored slightly to allow us to give them the main buffer to work on at runtime, and they would have to specify their own Urn, and the Urn's for their dependencies. So, any opinions? Is it a good idea? Does it solve the problem? Do i have no idea what I'm talking about?