Patch => Graph

git-svn-id: http://svn.drobilla.net/lad/trunk/ingen@4721 a436a847-0d15-0410-975c-d299462d15a1

146 files changed, 1942 insertions, 1937 deletions

diff --git a/bundles/ingen.lv2/ingen.ttl b/bundles/ingen.lv2/ingen.ttl
index 46b9840f..bf35f46a 100644
--- a/bundles/ingen.lv2/ingen.ttl
+++ b/bundles/ingen.lv2/ingen.ttl
@@ -13,14 +13,14 @@ ingen:
 	owl:imports <http://lv2plug.in/ns/lv2core> ;
 	rdfs:label "Ingen Ontology" ;
 	rdfs:comment """
-Describes "patches" of connected "nodes" (instances of plugins) which process
+Describes "graphs" of connected "blocks" (plugin instances) which process
 audio, MIDI, and other signals or messages.""" .
 
 ingen:Plugin
 	a owl:Class ;
 	rdfs:label "Plugin" ;
 	rdfs:comment """
-A class which can be instantiated into a ingen:Node.  A plugin has a set of input
+A class which can be instantiated into a ingen:Block.  A plugin has a set of input
 and output "ports".  In practice this class is semantically equivalent to
 lv2:Plugin, it only exists to allow the ingen ontology to be useful for
 "plugins" that aren't semantically LV2 plugins.  See the LV2 specification
@@ -28,13 +28,13 @@ for details about the required properties (rdf:type, doap:name, doap:license,
 and lv2:port).
 """ .
 
-ingen:Patch
+ingen:Graph
 	a owl:Class ;
 	rdfs:subClassOf ingen:Plugin ;
-	rdfs:label "Patch" ;
+	rdfs:label "Graph" ;
 	rdfs:comment """
-A collection of Nodes connected together form a Patch, which is itself
-a :Plugin (and thus can be part of another patch, and so on)
+A collection of Blocks connected together form a Graph, which can itself be a
+Block within a parent Graph, and so on.
 """ .
 
 ingen:canvasX
@@ -49,25 +49,25 @@ ingen:canvasY
 	rdfs:label "canvas Y" ;
 	rdfs:comment "The Y coordinate of an item on a canvas." .
 
-ingen:node
+ingen:block
 	a owl:ObjectProperty ;
-	rdfs:domain ingen:Patch ;
-	rdfs:range ingen:Node ;
-	rdfs:label "node" ;
-	rdfs:comment "Signifies a patch contains some node." .
+	rdfs:domain ingen:Graph ;
+	rdfs:range ingen:Block ;
+	rdfs:label "block" ;
+	rdfs:comment "Signifies a graph contains some block." .
 
 ingen:polyphony
 	a owl:DatatypeProperty ;
-	rdfs:domain ingen:Patch ;
+	rdfs:domain ingen:Graph ;
 	rdfs:range xsd:integer ;
 	rdfs:label "Polyphony" ;
 	rdfs:comment """
-The amount of polyphony in a Patch.  This defines the number of voices
-present on all :polyphonic children of this patch.  Because a Patch is
-also a Node, a Patch may have both :polyphony and :polyphonic properties.
+The amount of polyphony in a Graph.  This defines the number of voices
+present on all :polyphonic children of this graph.  Because a Graph is
+also a Block, a Graph may have both :polyphony and :polyphonic properties.
 These specify different things: :polyphony specifies the voice count
-of the Patch's children, and :polyphonic specifies whether the patch is
-seen as polyphonic to the Patch's parent.
+of the Graph's children, and :polyphonic specifies whether the graph is
+seen as polyphonic to the Graph's parent.
 """ .
 
 ingen:value
@@ -80,9 +80,9 @@ ingen:Object
 	a owl:Class ;
 	rdfs:label "Ingen Object" ;
 	rdfs:comment """
-A signal processing object which is part of a Patch.  An Object MUST have
+A signal processing object which is part of a Graph.  An Object MUST have
 exactly one lv2:symbol property.  This MAY be inferred from the URI where
-possible (e.g. in a system which publishes node URIs in a heirarchial way
+possible (e.g. in a system which publishes block URIs in a heirarchial way
 such that the parent can be 'chopped' to get a legal symbol).
 """ .
 
@@ -93,61 +93,61 @@ ingen:polyphonic
 	rdfs:label "Polyphonic" ;
 	rdfs:comment """
 Signifies this object should be replicated when it is part of a polyphonic
-patch.  The amount of polyphony (i.e. the number of voices) is determined
-by the :polyphony property of the containing patch.  This is a boolean
+graph.  The amount of polyphony (i.e. the number of voices) is determined
+by the :polyphony property of the containing graph.  This is a boolean
 property which defines whether the parent can access each voice individuall:
-All objects within a patch are either polyphonic or not from their parent's
+All objects within a graph are either polyphonic or not from their parent's
 perspective.  An Object may itself have "internal" polyphony but not be
 polyphonic according to this property, if those voices are mixed down.
 """ .
 
-ingen:Node
+ingen:Block
 	a owl:Class ;
 	rdfs:subClassOf ingen:Object ,
 		lv2:PluginBase ;
-	rdfs:label "Node" ;
+	rdfs:label "Block" ;
 	rdfs:comment """
-An instance of a Plugin.  Since a Patch is a Plugin, an instance of a Patch
-is also a Node.  A Node inherits all the properties of the plugin of which
+An instance of a Plugin.  Since a Graph is a Plugin, an instance of a Graph
+is also a Block.  A Block inherits all the properties of the plugin of which
 it is an instance, but may have properties of its own: any properties of
-the node take precedence over properties of the node's plugin.  This way a
-node can be expressed as a lightweight set of changes (e.g. input values)
-from its plugin or patch which may be defined elsewhere.
+the block take precedence over properties of the block's plugin.  This way a
+block can be expressed as a lightweight set of changes (e.g. input values)
+from its plugin or graph which may be defined elsewhere.
 
-A node MUST have at least one ingen:prototype property which is a subclass
+A block MUST have at least one ingen:prototype property which is a subclass
 of :Plugin.  When there are many such properties, an applications SHOULD
 use the most specific class it understands.
 """ .
 
 ingen:enabled
 	a owl:DatatypeProperty ;
-	rdfs:domain ingen:Node ;
+	rdfs:domain ingen:Block ;
 	rdfs:range xsd:boolean ;
 	rdfs:label "enabled" ;
-	rdfs:comment "Signifies the node is or should be running." .
+	rdfs:comment "Signifies the block is or should be running." .
 
 ingen:prototype
 	a owl:ObjectProperty ;
-	rdfs:domain ingen:Node ;
+	rdfs:domain ingen:Block ;
 	rdfs:label "prototype" ;
 	rdfs:comment """
-The object which this node is an instance of, or derived from.
+The object which this block is an instance of, or derived from.
 """ .
 
 ingen:Edge
 	a owl:Class ;
 	rdfs:label "Edge" ;
 	rdfs:comment """
-A connection between two ports.  Patches have a set of edges which
-define how its component nodes and ports are connected.  An Edge MUST
+A connection between two ports.  Graphs have a set of edges which
+define how its component blocks and ports are connected.  An Edge MUST
 have exactly one ingen:tail and exactly one ingen:head property.
 """ .
 
 ingen:edge
 	a owl:ObjectProperty ;
-	rdfs:domain ingen:Patch ;
+	rdfs:domain ingen:Graph ;
 	rdfs:range ingen:Edge ;
-	rdfs:comment "An edge contained in this patch." .
+	rdfs:comment "An edge contained in this graph." .
 
 ingen:tail
 	a owl:ObjectProperty ,
@@ -170,4 +170,4 @@ ingen:incidentTo
 		owl:FunctionalProperty ;
 	rdfs:domain ingen:Edge ;
 	rdfs:label "incident to" ;
-	rdfs:comment "A special property used to describe any edge incident to a port or node.  This is never saved in patch files, but is used in the control protocol to completely disconnect a Node or Port." .
+	rdfs:comment "A special property used to describe any edge incident to a port or block.  This is never saved in graph files, but is used in the control protocol to completely disconnect a Block or Port." .
diff --git a/ingen.ttl b/ingen.ttl
index 94dab16a..a75c73b5 100644
--- a/ingen.ttl
+++ b/ingen.ttl
@@ -30,7 +30,6 @@ by generic plugins.  Patching of audio, MIDI, and control data is supported.
 The engine and UI are completely separated in a network transparent way, making
 it possible to run one or more GUIs on separate machines from the engine.
 
-Ingen is closely based on LV2 plugin technology; Ingen patches are RDF
-documents in Turtle in a very similar format to the RDF definition of an
-LV2 plugin.
+Ingen is closely based on LV2 plugin technology; Ingen graphs are RDF documents
+in Turtle in a very similar format to the RDF definition of an LV2 plugin.
 """ .
diff --git a/ingen/AtomWriter.hpp b/ingen/AtomWriter.hpp
index 63c86028..37f91e74 100644
--- a/ingen/AtomWriter.hpp
+++ b/ingen/AtomWriter.hpp
@@ -63,7 +63,7 @@ public:
 	void disconnect(const Raul::Path& tail,
 	                const Raul::Path& head);
 
-	void disconnect_all(const Raul::Path& parent_patch_path,
+	void disconnect_all(const Raul::Path& graph,
 	                    const Raul::Path& path);
 
 	void set_property(const Raul::URI&  subject,
diff --git a/ingen/ClashAvoider.hpp b/ingen/ClashAvoider.hpp
index db3c1b60..49a3000a 100644
--- a/ingen/ClashAvoider.hpp
+++ b/ingen/ClashAvoider.hpp
@@ -71,7 +71,7 @@ public:
 	virtual void disconnect(const Raul::Path& tail,
 	                        const Raul::Path& head);
 
-	virtual void disconnect_all(const Raul::Path& parent_patch_path,
+	virtual void disconnect_all(const Raul::Path& graph,
 	                            const Raul::Path& path);
 
 	virtual void set_property(const Raul::URI&  subject_path,
diff --git a/ingen/GraphObject.hpp b/ingen/GraphObject.hpp
index 5ad3b156..cca3af45 100644
--- a/ingen/GraphObject.hpp
+++ b/ingen/GraphObject.hpp
@@ -33,7 +33,7 @@ class Edge;
 class Plugin;
 class Store;
 
-/** An object on the audio graph - Patch, Block, Port, etc.
+/** An object on the audio graph - Graph, Block, Port, etc.
  *
  * @ingroup Ingen
  */
@@ -41,7 +41,7 @@ class GraphObject : public Resource
 {
 public:
 	enum GraphType {
-		PATCH,
+		GRAPH,
 		BLOCK,
 		PORT
 	};
@@ -49,11 +49,11 @@ public:
 	typedef std::pair<const GraphObject*, const GraphObject*> EdgesKey;
 	typedef std::map< EdgesKey, SharedPtr<Edge> > Edges;
 
-	// Patches only
+	// Graphs only
 	Edges&       edges()       { return _edges; }
 	const Edges& edges() const { return _edges; }
 
-	// Blocks and patches only
+	// Blocks and graphs only
 	virtual uint32_t      num_ports()          const { return 0; }
 	virtual GraphObject*  port(uint32_t index) const { return NULL; }
 	virtual const Plugin* plugin()             const { return NULL; }
@@ -88,7 +88,7 @@ protected:
 		: Resource(uris, path_to_uri(path))
 	{}
 
-	Edges _edges;  ///< Patches only
+	Edges _edges;  ///< Graphs only
 };
 
 } // namespace Ingen
diff --git a/ingen/Interface.hpp b/ingen/Interface.hpp
index 0ad9e1ba..59749dec 100644
--- a/ingen/Interface.hpp
+++ b/ingen/Interface.hpp
@@ -78,7 +78,7 @@ public:
 	virtual void disconnect(const Raul::Path& tail,
 	                        const Raul::Path& head) = 0;
 
-	virtual void disconnect_all(const Raul::Path& parent_patch,
+	virtual void disconnect_all(const Raul::Path& graph,
 	                            const Raul::Path& path) = 0;
 
 	virtual void set_property(const Raul::URI&  subject,
diff --git a/ingen/Plugin.hpp b/ingen/Plugin.hpp
index 17601385..bc8220da 100644
--- a/ingen/Plugin.hpp
+++ b/ingen/Plugin.hpp
@@ -35,7 +35,7 @@ public:
 		: Resource(uris, uri)
 	{}
 
-	enum Type { NIL, LV2, Internal, Patch };
+	enum Type { NIL, LV2, Internal, Graph };
 
 	virtual Type type() const = 0;
 
@@ -44,7 +44,7 @@ public:
 			Raul::URI("http://drobilla.net/ns/ingen#nil"),
 			Raul::URI(LV2_CORE__Plugin),
 			Raul::URI("http://drobilla.net/ns/ingen#Internal"),
-			Raul::URI("http://drobilla.net/ns/ingen#Patch")
+			Raul::URI("http://drobilla.net/ns/ingen#Graph")
 		};
 
 		return uris[type];
@@ -57,8 +57,8 @@ public:
 			return LV2;
 		else if (uri == type_uri(Internal))
 			return Internal;
-		else if (uri == type_uri(Patch))
-			return Patch;
+		else if (uri == type_uri(Graph))
+			return Graph;
 		else
 			return NIL;
 	}
diff --git a/ingen/Resource.hpp b/ingen/Resource.hpp
index c9bbc2ab..025a963f 100644
--- a/ingen/Resource.hpp
+++ b/ingen/Resource.hpp
@@ -158,7 +158,7 @@ public:
 	 */
 	static bool type(const URIs&       uris,
 	                 const Properties& properties,
-	                 bool&             patch,
+	                 bool&             graph,
 	                 bool&             block,
 	                 bool&             port,
 	                 bool&             is_output);
diff --git a/ingen/Store.hpp b/ingen/Store.hpp
index 87f6f7e0..1f329484 100644
--- a/ingen/Store.hpp
+++ b/ingen/Store.hpp
@@ -28,7 +28,7 @@
 
 namespace Ingen {
 
-/** Store of objects in the patch hierarchy.
+/** Store of objects in the graph hierarchy.
  * @ingroup IngenShared
  */
 class Store : public Raul::Noncopyable
diff --git a/ingen/URIs.hpp b/ingen/URIs.hpp
index 25a26c95..0fc05a4e 100644
--- a/ingen/URIs.hpp
+++ b/ingen/URIs.hpp
@@ -72,8 +72,8 @@ public:
 	const Quark doap_name;
 	const Quark ingen_Block;
 	const Quark ingen_Edge;
+	const Quark ingen_Graph;
 	const Quark ingen_Internal;
-	const Quark ingen_Patch;
 	const Quark ingen_activity;
 	const Quark ingen_block;
 	const Quark ingen_broadcast;
diff --git a/ingen/client/BlockModel.hpp b/ingen/client/BlockModel.hpp
index dbb0faf3..d0bae8de 100644
--- a/ingen/client/BlockModel.hpp
+++ b/ingen/client/BlockModel.hpp
@@ -48,7 +48,7 @@ public:
 	BlockModel(const BlockModel& copy);
 	virtual ~BlockModel();
 
-	GraphType graph_type() const { return GraphObject::PATCH; }
+	GraphType graph_type() const { return GraphObject::GRAPH; }
 
 	typedef std::vector< SharedPtr<const PortModel> > Ports;
 
diff --git a/ingen/client/ClientStore.hpp b/ingen/client/ClientStore.hpp
index 6da7310e..e7e6105b 100644
--- a/ingen/client/ClientStore.hpp
+++ b/ingen/client/ClientStore.hpp
@@ -38,8 +38,8 @@ class URIs;
 namespace Client {
 
 class BlockModel;
+class GraphModel;
 class ObjectModel;
-class PatchModel;
 class PluginModel;
 class PortModel;
 class SigClientInterface;
@@ -94,7 +94,7 @@ public:
 	void disconnect(const Raul::Path& tail,
 	                const Raul::Path& head);
 
-	void disconnect_all(const Raul::Path& parent_patch,
+	void disconnect_all(const Raul::Path& graph,
 	                    const Raul::Path& path);
 
 	void del(const Raul::URI& uri);
@@ -117,7 +117,7 @@ private:
 
 	void add_plugin(SharedPtr<PluginModel> plugin);
 
-	SharedPtr<PatchModel> connection_patch(const Raul::Path& tail_path,
+	SharedPtr<GraphModel> connection_graph(const Raul::Path& tail_path,
 	                                       const Raul::Path& head_path);
 
 	void bundle_begin() {}
diff --git a/ingen/client/PatchModel.hpp b/ingen/client/GraphModel.hpp
index b4f56799..03a41891 100644
--- a/ingen/client/PatchModel.hpp
+++ b/ingen/client/GraphModel.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_CLIENT_PATCHMODEL_HPP
-#define INGEN_CLIENT_PATCHMODEL_HPP
+#ifndef INGEN_CLIENT_GRAPHMODEL_HPP
+#define INGEN_CLIENT_GRAPHMODEL_HPP
 
 #include "ingen/client/BlockModel.hpp"
 #include "raul/SharedPtr.hpp"
@@ -26,16 +26,16 @@ namespace Client {
 class ClientStore;
 class EdgeModel;
 
-/** Client's model of a patch.
+/** Client's model of a graph.
  *
  * @ingroup IngenClient
  */
-class PatchModel : public BlockModel
+class GraphModel : public BlockModel
 {
 public:
 	/* WARNING: Copy constructor creates a shallow copy WRT connections */
 
-	GraphType graph_type() const { return GraphObject::PATCH; }
+	GraphType graph_type() const { return GraphObject::GRAPH; }
 
 	SharedPtr<EdgeModel> get_edge(const Ingen::GraphObject* tail,
 	                              const Ingen::GraphObject* head);
@@ -53,11 +53,9 @@ public:
 private:
 	friend class ClientStore;
 
-	PatchModel(URIs& uris, const Raul::Path& patch_path)
-		: BlockModel(
-			uris, Raul::URI("http://drobilla.net/ns/ingen#Patch"), patch_path)
-	{
-	}
+	GraphModel(URIs& uris, const Raul::Path& graph_path)
+		: BlockModel(uris, uris.ingen_Graph, graph_path)
+	{}
 
 	void clear();
 	void add_child(SharedPtr<ObjectModel> c);
@@ -71,4 +69,4 @@ private:
 } // namespace Client
 } // namespace Ingen
 
-#endif // INGEN_CLIENT_PATCHMODEL_HPP
+#endif // INGEN_CLIENT_GRAPHMODEL_HPP
diff --git a/ingen/client/ObjectModel.hpp b/ingen/client/ObjectModel.hpp
index b51e82e6..c9f4e6d1 100644
--- a/ingen/client/ObjectModel.hpp
+++ b/ingen/client/ObjectModel.hpp
@@ -41,7 +41,7 @@ namespace Client {
 
 class ClientStore;
 
-/** Base class for all GraphObject models (BlockModel, PatchModel, PortModel).
+/** Base class for all GraphObject models (BlockModel, GraphModel, PortModel).
  *
  * There are no non-const public methods intentionally, models are not allowed
  * to be manipulated directly by anything (but the Store) because of the
diff --git a/ingen/client/PluginModel.hpp b/ingen/client/PluginModel.hpp
index 7475e57a..7e082879 100644
--- a/ingen/client/PluginModel.hpp
+++ b/ingen/client/PluginModel.hpp
@@ -37,7 +37,7 @@ class URIs;
 
 namespace Client {
 
-class PatchModel;
+class GraphModel;
 class BlockModel;
 class PluginUI;
 
diff --git a/ingen/client/SigClientInterface.hpp b/ingen/client/SigClientInterface.hpp
index a330d31e..dc6676f7 100644
--- a/ingen/client/SigClientInterface.hpp
+++ b/ingen/client/SigClientInterface.hpp
@@ -103,8 +103,8 @@ protected:
 	void disconnect(const Raul::Path& tail, const Raul::Path& head)
 		{ EMIT(disconnection, tail, head); }
 
-	void disconnect_all(const Raul::Path& parent_patch_path, const Raul::Path& path)
-		{ EMIT(disconnect_all, parent_patch_path, path); }
+	void disconnect_all(const Raul::Path& graph, const Raul::Path& path)
+		{ EMIT(disconnect_all, graph, path); }
 
 	void set_property(const Raul::URI& subject, const Raul::URI& key, const Raul::Atom& value)
 		{ EMIT(property_change, subject, key, value); }
diff --git a/ingen/client/ThreadedSigClientInterface.hpp b/ingen/client/ThreadedSigClientInterface.hpp
index 633bd265..a89108bc 100644
--- a/ingen/client/ThreadedSigClientInterface.hpp
+++ b/ingen/client/ThreadedSigClientInterface.hpp
@@ -101,8 +101,8 @@ public:
 	void disconnect(const Raul::Path& tail, const Raul::Path& head)
 		{ push_sig(sigc::bind(disconnection_slot, tail, head)); }
 
-	void disconnect_all(const Raul::Path& parent_patch_path, const Raul::Path& path)
-		{ push_sig(sigc::bind(disconnect_all_slot, parent_patch_path, path)); }
+	void disconnect_all(const Raul::Path& graph, const Raul::Path& path)
+		{ push_sig(sigc::bind(disconnect_all_slot, graph, path)); }
 
 	void set_property(const Raul::URI& subject, const Raul::URI& key, const Raul::Atom& value)
 		{ push_sig(sigc::bind(property_change_slot, subject, key, value)); }
diff --git a/ingen/serialisation/Serialiser.hpp b/ingen/serialisation/Serialiser.hpp
index b4c0dfd3..ae18693e 100644
--- a/ingen/serialisation/Serialiser.hpp
+++ b/ingen/serialisation/Serialiser.hpp
@@ -52,7 +52,7 @@ public:
 	virtual void to_file(SharedPtr<const GraphObject> object,
 	                     const std::string&           filename);
 
-	virtual void write_bundle(SharedPtr<const GraphObject> patch,
+	virtual void write_bundle(SharedPtr<const GraphObject> graph,
 	                          const std::string&           path);
 
 	virtual std::string to_string(SharedPtr<const GraphObject> object,
diff --git a/src/AtomWriter.cpp b/src/AtomWriter.cpp
index 466c6a7e..34ea62d0 100644
--- a/src/AtomWriter.cpp
+++ b/src/AtomWriter.cpp
@@ -213,14 +213,14 @@ AtomWriter::disconnect(const Raul::Path& tail,
 }
 
 void
-AtomWriter::disconnect_all(const Raul::Path& parent_patch_path,
+AtomWriter::disconnect_all(const Raul::Path& graph,
                            const Raul::Path& path)
 {
 	LV2_Atom_Forge_Frame msg;
 	lv2_atom_forge_blank(&_forge, &msg, next_id(), _uris.patch_Delete);
 
 	lv2_atom_forge_property_head(&_forge, _uris.patch_subject, 0);
-	forge_uri(GraphObject::path_to_uri(parent_patch_path));
+	forge_uri(GraphObject::path_to_uri(graph));
 
 	lv2_atom_forge_property_head(&_forge, _uris.patch_body, 0);
 	LV2_Atom_Forge_Frame edge;
diff --git a/src/Builder.cpp b/src/Builder.cpp
index f0edd438..49f5d76b 100644
--- a/src/Builder.cpp
+++ b/src/Builder.cpp
@@ -41,7 +41,7 @@ Builder::build(SharedPtr<const GraphObject> object)
 void
 Builder::connect(SharedPtr<const GraphObject> object)
 {
-	if (object->graph_type() == GraphObject::PATCH) {
+	if (object->graph_type() == GraphObject::GRAPH) {
 		for (GraphObject::Edges::const_iterator i = object->edges().begin();
 		     i != object->edges().end(); ++i) {
 			_interface.connect(i->second->tail_path(), i->second->head_path());
diff --git a/src/ClashAvoider.cpp b/src/ClashAvoider.cpp
index 13afc283..fce60291 100644
--- a/src/ClashAvoider.cpp
+++ b/src/ClashAvoider.cpp
@@ -170,10 +170,10 @@ ClashAvoider::disconnect(const Raul::Path& tail,
 }
 
 void
-ClashAvoider::disconnect_all(const Raul::Path& parent_patch,
+ClashAvoider::disconnect_all(const Raul::Path& graph,
                              const Raul::Path& path)
 {
-	_target.disconnect_all(map_path(parent_patch), map_path(path));
+	_target.disconnect_all(map_path(graph), map_path(path));
 }
 
 void
diff --git a/src/Configuration.cpp b/src/Configuration.cpp
index 4db54b65..2a5e69f7 100644
--- a/src/Configuration.cpp
+++ b/src/Configuration.cpp
@@ -27,11 +27,11 @@ Configuration::Configuration()
 	"clients, can communicate with the engine via any supported protocol, or host the\n"
 	"engine in the same process.  Many clients can connect to an engine at once.\n\n"
 	"Examples:\n"
-	"  ingen -e                  # Run an engine, listen for connections\n"
-	"  ingen -g                  # Run a GUI, connect to running engine\n"
-	"  ingen -eg                 # Run an engine and a GUI in one process\n"
-	"  ingen -egl patch.ttl      # Run an engine and a GUI and load a patch file\n"
-	"  ingen -egl patch.ingen    # Run an engine and a GUI and load a patch bundle")
+	"  ingen -e              # Run an engine, listen for connections\n"
+	"  ingen -g              # Run a GUI, connect to running engine\n"
+	"  ingen -eg             # Run an engine and a GUI in one process\n"
+	"  ingen -egl foo.ttl    # Run an engine and a GUI and load a graph\n"
+	"  ingen -egl foo.ingen  # Run an engine and a GUI and load a graph")
 {
 	add("client-port", 'C', "Client port", INT, Value());
 	add("connect",     'c', "Connect to engine URI", STRING, Value("unix:///tmp/ingen.sock"));
@@ -43,9 +43,9 @@ Configuration::Configuration()
 	add("jack-client", 'n', "JACK client name", STRING, Value("ingen"));
 	add("jack-server", 's', "JACK server name", STRING, Value(""));
 	add("uuid",        'u', "JACK session UUID", STRING, Value());
-	add("load",        'l', "Load patch", STRING, Value());
+	add("load",        'l', "Load graph", STRING, Value());
 	add("packet-size", 'k', "Maximum UDP packet size", INT, Value(4096));
-	add("path",        'L', "Target path for loaded patch", STRING, Value());
+	add("path",        'L', "Target path for loaded graph", STRING, Value());
 	add("queue-size",  'q', "Event queue size", INT, Value(4096));
 	add("run",         'r', "Run script", STRING, Value());
 }
diff --git a/src/Resource.cpp b/src/Resource.cpp
index a317ff67..7db46a81 100644
--- a/src/Resource.cpp
+++ b/src/Resource.cpp
@@ -110,7 +110,7 @@ Resource::get_property(const Raul::URI& uri) const
 bool
 Resource::type(const URIs&       uris,
                const Properties& properties,
-               bool&             patch,
+               bool&             graph,
                bool&             block,
                bool&             port,
                bool&             is_output)
@@ -118,15 +118,15 @@ Resource::type(const URIs&       uris,
 	typedef Resource::Properties::const_iterator iterator;
 	const std::pair<iterator, iterator> types_range = properties.equal_range(uris.rdf_type);
 
-	patch = block = port = is_output = false;
+	graph = block = port = is_output = false;
 	for (iterator i = types_range.first; i != types_range.second; ++i) {
 		const Raul::Atom& atom = i->second;
 		if (atom.type() != uris.forge.URI && atom.type() != uris.forge.URID) {
 			continue; // Non-URI type, ignore garbage data
 		}
 
-		if (atom == uris.ingen_Patch) {
-			patch = true;
+		if (atom == uris.ingen_Graph) {
+			graph = true;
 		} else if (atom == uris.ingen_Block) {
 			block = true;
 		} else if (atom == uris.lv2_InputPort) {
@@ -138,13 +138,13 @@ Resource::type(const URIs&       uris,
 		}
 	}
 
-	if (patch && block && !port) { // => patch
+	if (graph && block && !port) { // => graph
 		block = false;
 		return true;
-	} else if (port && (patch || block)) { // nonsense
+	} else if (port && (graph || block)) { // nonsense
 		port = false;
 		return false;
-	} else if (patch || block || port) { // recognized type
+	} else if (graph || block || port) { // recognized type
 		return true;
 	} else { // unknown
 		return false;
diff --git a/src/URIs.cpp b/src/URIs.cpp
index 227b6162..78f57f58 100644
--- a/src/URIs.cpp
+++ b/src/URIs.cpp
@@ -57,8 +57,8 @@ URIs::URIs(Forge& f, URIMap* map)
 	, doap_name             (forge, map, "http://usefulinc.com/ns/doap#name")
 	, ingen_Block           (forge, map, NS_INGEN "Block")
 	, ingen_Edge            (forge, map, NS_INGEN "Edge")
+	, ingen_Graph           (forge, map, NS_INGEN "Graph")
 	, ingen_Internal        (forge, map, NS_INGEN "Internal")
-	, ingen_Patch           (forge, map, NS_INGEN "Patch")
 	, ingen_activity        (forge, map, NS_INGEN "activity")
 	, ingen_block           (forge, map, NS_INGEN "block")
 	, ingen_broadcast       (forge, map, NS_INGEN "broadcast")
diff --git a/src/client/ClientStore.cpp b/src/client/ClientStore.cpp
index 07b44b84..6d4cbfd4 100644
--- a/src/client/ClientStore.cpp
+++ b/src/client/ClientStore.cpp
@@ -19,7 +19,7 @@
 #include "ingen/client/EdgeModel.hpp"
 #include "ingen/client/BlockModel.hpp"
 #include "ingen/client/ObjectModel.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 #include "ingen/client/PluginModel.hpp"
 #include "ingen/client/PortModel.hpp"
 #include "ingen/client/SigClientInterface.hpp"
@@ -223,9 +223,9 @@ ClientStore::put(const Raul::URI&            uri,
 	std::cerr << "}" << endl;
 #endif
 
-	bool is_patch, is_block, is_port, is_output;
+	bool is_graph, is_block, is_port, is_output;
 	Resource::type(uris(), properties,
-	               is_patch, is_block, is_port, is_output);
+	               is_graph, is_block, is_port, is_output);
 
 	// Check if uri is a plugin
 	Iterator t = properties.find(_uris.rdf_type);
@@ -233,8 +233,8 @@ ClientStore::put(const Raul::URI&            uri,
 		const Raul::Atom&  type(t->second);
 		const Raul::URI    type_uri(type.get_uri());
 		const Plugin::Type plugin_type(Plugin::type_from_uri(type_uri));
-		if (plugin_type == Plugin::Patch) {
-			is_patch = true;
+		if (plugin_type == Plugin::Graph) {
+			is_graph = true;
 		} else if (plugin_type != Plugin::NIL) {
 			SharedPtr<PluginModel> p(
 				new PluginModel(uris(), uri, type_uri, properties));
@@ -258,11 +258,11 @@ ClientStore::put(const Raul::URI&            uri,
 	}
 
 	if (path.is_root()) {
-		is_patch = true;
+		is_graph = true;
 	}
 
-	if (is_patch) {
-		SharedPtr<PatchModel> model(new PatchModel(uris(), path));
+	if (is_graph) {
+		SharedPtr<GraphModel> model(new GraphModel(uris(), path));
 		model->set_properties(properties);
 		add_object(model);
 	} else if (is_block) {
@@ -373,29 +373,29 @@ ClientStore::set_property(const Raul::URI&  subject_uri,
 	}
 }
 
-SharedPtr<PatchModel>
-ClientStore::connection_patch(const Raul::Path& tail_path,
+SharedPtr<GraphModel>
+ClientStore::connection_graph(const Raul::Path& tail_path,
                               const Raul::Path& head_path)
 {
-	SharedPtr<PatchModel> patch;
+	SharedPtr<GraphModel> graph;
 
 	if (tail_path.parent() == head_path.parent())
-		patch = PtrCast<PatchModel>(_object(tail_path.parent()));
+		graph = PtrCast<GraphModel>(_object(tail_path.parent()));
 
-	if (!patch && tail_path.parent() == head_path.parent().parent())
-		patch = PtrCast<PatchModel>(_object(tail_path.parent()));
+	if (!graph && tail_path.parent() == head_path.parent().parent())
+		graph = PtrCast<GraphModel>(_object(tail_path.parent()));
 
-	if (!patch && tail_path.parent().parent() == head_path.parent())
-		patch = PtrCast<PatchModel>(_object(head_path.parent()));
+	if (!graph && tail_path.parent().parent() == head_path.parent())
+		graph = PtrCast<GraphModel>(_object(head_path.parent()));
 
-	if (!patch)
-		patch = PtrCast<PatchModel>(_object(tail_path.parent().parent()));
+	if (!graph)
+		graph = PtrCast<GraphModel>(_object(tail_path.parent().parent()));
 
-	if (!patch)
-		_log.error(Raul::fmt("Unable to find path for edge %1% => %2%\n")
+	if (!graph)
+		_log.error(Raul::fmt("Unable to find graph for edge %1% => %2%\n")
 		           % tail_path % head_path);
 
-	return patch;
+	return graph;
 }
 
 bool
@@ -406,13 +406,13 @@ ClientStore::attempt_connection(const Raul::Path& tail_path,
 	SharedPtr<PortModel> head = PtrCast<PortModel>(_object(head_path));
 
 	if (tail && head) {
-		SharedPtr<PatchModel> patch = connection_patch(tail_path, head_path);
+		SharedPtr<GraphModel> graph = connection_graph(tail_path, head_path);
 		SharedPtr<EdgeModel>  cm(new EdgeModel(tail, head));
 
 		tail->connected_to(head);
 		head->connected_to(tail);
 
-		patch->add_edge(cm);
+		graph->add_edge(cm);
 		return true;
 	} else {
 		_log.warn(Raul::fmt("Failed to connect %1% => %2%\n")
@@ -441,26 +441,26 @@ ClientStore::disconnect(const Raul::Path& src_path,
 	if (head)
 		head->disconnected_from(tail);
 
-	SharedPtr<PatchModel> patch = connection_patch(src_path, dst_path);
-	if (patch)
-		patch->remove_edge(tail.get(), head.get());
+	SharedPtr<GraphModel> graph = connection_graph(src_path, dst_path);
+	if (graph)
+		graph->remove_edge(tail.get(), head.get());
 }
 
 void
-ClientStore::disconnect_all(const Raul::Path& parent_patch,
+ClientStore::disconnect_all(const Raul::Path& parent_graph,
                             const Raul::Path& path)
 {
-	SharedPtr<PatchModel>  patch  = PtrCast<PatchModel>(_object(parent_patch));
+	SharedPtr<GraphModel>  graph  = PtrCast<GraphModel>(_object(parent_graph));
 	SharedPtr<ObjectModel> object = _object(path);
 
-	if (!patch || !object) {
+	if (!graph || !object) {
 		_log.error(Raul::fmt("Bad disconnect all notification %1% in %2%\n")
-		           % path % parent_patch);
+		           % path % parent_graph);
 		return;
 	}
 
-	const PatchModel::Edges edges = patch->edges();
-	for (PatchModel::Edges::const_iterator i = edges.begin();
+	const GraphModel::Edges edges = graph->edges();
+	for (GraphModel::Edges::const_iterator i = edges.begin();
 	     i != edges.end(); ++i) {
 		SharedPtr<EdgeModel> c = PtrCast<EdgeModel>(i->second);
 		if (c->tail()->parent() == object
@@ -469,7 +469,7 @@ ClientStore::disconnect_all(const Raul::Path& parent_patch,
 		    || c->head()->path() == path) {
 			c->tail()->disconnected_from(c->head());
 			c->head()->disconnected_from(c->tail());
-			patch->remove_edge(c->tail().get(), c->head().get());
+			graph->remove_edge(c->tail().get(), c->head().get());
 		}
 	}
 }
diff --git a/src/client/PatchModel.cpp b/src/client/GraphModel.cpp
index 9b622cda..88943978 100644
--- a/src/client/PatchModel.cpp
+++ b/src/client/GraphModel.cpp
@@ -16,11 +16,11 @@
 
 #include <cassert>
 
+#include "ingen/URIs.hpp"
+#include "ingen/client/BlockModel.hpp"
 #include "ingen/client/ClientStore.hpp"
 #include "ingen/client/EdgeModel.hpp"
-#include "ingen/client/BlockModel.hpp"
-#include "ingen/client/PatchModel.hpp"
-#include "ingen/URIs.hpp"
+#include "ingen/client/GraphModel.hpp"
 
 using namespace std;
 
@@ -28,7 +28,7 @@ namespace Ingen {
 namespace Client {
 
 void
-PatchModel::add_child(SharedPtr<ObjectModel> c)
+GraphModel::add_child(SharedPtr<ObjectModel> c)
 {
 	assert(c->parent().get() == this);
 
@@ -45,7 +45,7 @@ PatchModel::add_child(SharedPtr<ObjectModel> c)
 }
 
 bool
-PatchModel::remove_child(SharedPtr<ObjectModel> o)
+GraphModel::remove_child(SharedPtr<ObjectModel> o)
 {
 	assert(o->path().is_child_of(path()));
 	assert(o->parent().get() == this);
@@ -82,7 +82,7 @@ PatchModel::remove_child(SharedPtr<ObjectModel> o)
 }
 
 void
-PatchModel::clear()
+GraphModel::clear()
 {
 	_edges.clear();
 
@@ -93,7 +93,7 @@ PatchModel::clear()
 }
 
 SharedPtr<EdgeModel>
-PatchModel::get_edge(const GraphObject* tail, const GraphObject* head)
+GraphModel::get_edge(const GraphObject* tail, const GraphObject* head)
 {
 	Edges::iterator i = _edges.find(make_pair(tail, head));
 	if (i != _edges.end())
@@ -102,15 +102,15 @@ PatchModel::get_edge(const GraphObject* tail, const GraphObject* head)
 		return SharedPtr<EdgeModel>();
 }
 
-/** Add a connection to this patch.
+/** Add a connection to this graph.
  *
  * A reference to  @a cm is taken, released on deletion or removal.
  * If @a cm only contains paths (not pointers to the actual ports), the ports
  * will be found and set.  The ports referred to not existing as children of
- * this patch is a fatal error.
+ * this graph is a fatal error.
  */
 void
-PatchModel::add_edge(SharedPtr<EdgeModel> cm)
+GraphModel::add_edge(SharedPtr<EdgeModel> cm)
 {
 	// Store should have 'resolved' the connection already
 	assert(cm);
@@ -138,7 +138,7 @@ PatchModel::add_edge(SharedPtr<EdgeModel> cm)
 }
 
 void
-PatchModel::remove_edge(const GraphObject* tail, const GraphObject* head)
+GraphModel::remove_edge(const GraphObject* tail, const GraphObject* head)
 {
 	Edges::iterator i = _edges.find(make_pair(tail, head));
 	if (i != _edges.end()) {
@@ -149,21 +149,21 @@ PatchModel::remove_edge(const GraphObject* tail, const GraphObject* head)
 }
 
 bool
-PatchModel::enabled() const
+GraphModel::enabled() const
 {
 	const Raul::Atom& enabled = get_property(_uris.ingen_enabled);
 	return (enabled.is_valid() && enabled.get_bool());
 }
 
 uint32_t
-PatchModel::internal_poly() const
+GraphModel::internal_poly() const
 {
 	const Raul::Atom& poly = get_property(_uris.ingen_polyphony);
 	return poly.is_valid() ? poly.get_int32() : 1;
 }
 
 bool
-PatchModel::polyphonic() const
+GraphModel::polyphonic() const
 {
 	const Raul::Atom& poly = get_property(_uris.ingen_polyphonic);
 	return poly.is_valid() && poly.get_bool();
diff --git a/src/client/PluginModel.cpp b/src/client/PluginModel.cpp
index 53736a3e..371e6b46 100644
--- a/src/client/PluginModel.cpp
+++ b/src/client/PluginModel.cpp
@@ -24,7 +24,7 @@
 #include "raul/Atom.hpp"
 #include "raul/Path.hpp"
 
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 #include "ingen/client/PluginModel.hpp"
 #include "ingen/client/PluginUI.hpp"
 
diff --git a/src/client/wscript b/src/client/wscript
index c85ee5ab..c2b12ef3 100644
--- a/src/client/wscript
+++ b/src/client/wscript
@@ -14,8 +14,8 @@ def build(bld):
     obj.source = '''
         BlockModel.cpp
         ClientStore.cpp
+        GraphModel.cpp
         ObjectModel.cpp
-        PatchModel.cpp
         PluginModel.cpp
         PluginUI.cpp
         PortModel.cpp
diff --git a/src/gui/App.cpp b/src/gui/App.cpp
index de35de54..96bb1254 100644
--- a/src/gui/App.cpp
+++ b/src/gui/App.cpp
@@ -29,7 +29,7 @@
 #include "ingen/World.hpp"
 #include "ingen/client/ClientStore.hpp"
 #include "ingen/client/ObjectModel.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 #include "ingen/client/SigClientInterface.hpp"
 #include "ingen/runtime_paths.hpp"
 #include "lilv/lilv.h"
@@ -41,10 +41,10 @@
 #include "LoadPluginWindow.hpp"
 #include "MessagesWindow.hpp"
 #include "NodeModule.hpp"
-#include "PatchTreeWindow.hpp"
-#include "PatchWindow.hpp"
+#include "GraphTreeWindow.hpp"
+#include "GraphWindow.hpp"
 #include "Port.hpp"
-#include "SubpatchModule.hpp"
+#include "SubgraphModule.hpp"
 #include "ThreadedLoader.hpp"
 #include "WidgetFactory.hpp"
 #include "WindowFactory.hpp"
@@ -78,11 +78,11 @@ App::App(Ingen::World* world)
 
 	WidgetFactory::get_widget_derived("connect_win", _connect_window);
 	WidgetFactory::get_widget_derived("messages_win", _messages_window);
-	WidgetFactory::get_widget_derived("patch_tree_win", _patch_tree_window);
+	WidgetFactory::get_widget_derived("graph_tree_win", _graph_tree_window);
 	WidgetFactory::get_widget("about_win", _about_dialog);
 	_connect_window->init_dialog(*this);
 	_messages_window->init_window(*this);
-	_patch_tree_window->init_window(*this);
+	_graph_tree_window->init_window(*this);
 	_about_dialog->property_program_name() = "Ingen";
 	_about_dialog->property_logo_icon_name() = "ingen";
 
@@ -140,7 +140,7 @@ App::run()
 
 	// Run main iterations here until we're attached to the engine. Otherwise
 	// with 'ingen -egl' we'd get a bunch of notifications about load
-	// immediately before even knowing about the root patch or plugins)
+	// immediately before even knowing about the root graph or plugins)
 	while (!_connect_window->attached())
 		if (_main->iteration())
 			break;
@@ -163,7 +163,7 @@ App::attach(SharedPtr<SigClientInterface> client)
 	_store  = SharedPtr<ClientStore>(new ClientStore(_world->uris(), _world->log(), _world->interface(), client));
 	_loader = SharedPtr<ThreadedLoader>(new ThreadedLoader(*this, _world->interface()));
 
-	_patch_tree_window->init(*this, *_store);
+	_graph_tree_window->init(*this, *_store);
 
 	_client->signal_response().connect(
 		sigc::mem_fun(this, &App::response));
diff --git a/src/gui/App.hpp b/src/gui/App.hpp
index 32c59300..ac909b2f 100644
--- a/src/gui/App.hpp
+++ b/src/gui/App.hpp
@@ -40,7 +40,7 @@ namespace Ingen {
 	class World;
 	namespace Client {
 		class ClientStore;
-		class PatchModel;
+		class GraphModel;
 		class PluginModel;
 		class PortModel;
 		class SigClientInterface;
@@ -55,9 +55,9 @@ namespace Ingen {
 namespace GUI {
 
 class MessagesWindow;
-class PatchCanvas;
-class PatchTreeView;
-class PatchTreeWindow;
+class GraphCanvas;
+class GraphTreeView;
+class GraphTreeWindow;
 class ConnectWindow;
 class Configuration;
 class ThreadedLoader;
@@ -100,7 +100,7 @@ public:
 
 	ConnectWindow*   connect_window()  const { return _connect_window; }
 	MessagesWindow*  messages_dialog() const { return _messages_window; }
-	PatchTreeWindow* patch_tree()      const { return _patch_tree_window; }
+	GraphTreeWindow* graph_tree()      const { return _graph_tree_window; }
 	Configuration*   configuration()   const { return _configuration; }
 	WindowFactory*   window_factory()  const { return _window_factory; }
 
@@ -158,7 +158,7 @@ protected:
 
 	ConnectWindow*    _connect_window;
 	MessagesWindow*   _messages_window;
-	PatchTreeWindow*  _patch_tree_window;
+	GraphTreeWindow*  _graph_tree_window;
 	Gtk::AboutDialog* _about_dialog;
 	WindowFactory*    _window_factory;
 
diff --git a/src/gui/BreadCrumbs.cpp b/src/gui/BreadCrumbs.cpp
index 29b149a5..bc6fc756 100644
--- a/src/gui/BreadCrumbs.cpp
+++ b/src/gui/BreadCrumbs.cpp
@@ -39,14 +39,14 @@ BreadCrumbs::BreadCrumbs(App& app)
 	set_can_focus(false);
 }
 
-SharedPtr<PatchView>
+SharedPtr<GraphView>
 BreadCrumbs::view(const Raul::Path& path)
 {
 	for (std::list<BreadCrumb*>::const_iterator i = _breadcrumbs.begin(); i != _breadcrumbs.end(); ++i)
 		if ((*i)->path() == path)
 			return (*i)->view();
 
-	return SharedPtr<PatchView>();
+	return SharedPtr<GraphView>();
 }
 
 /** Sets up the crumbs to display @a path.
@@ -55,7 +55,7 @@ BreadCrumbs::view(const Raul::Path& path)
  * children preserved.
  */
 void
-BreadCrumbs::build(Raul::Path path, SharedPtr<PatchView> view)
+BreadCrumbs::build(Raul::Path path, SharedPtr<GraphView> view)
 {
 	bool old_enable_signal = _enable_signal;
 	_enable_signal = false;
@@ -68,7 +68,7 @@ BreadCrumbs::build(Raul::Path path, SharedPtr<PatchView> view)
 				if (!(*i)->view())
 					(*i)->set_view(view);
 
-				// views are expensive, having two around for the same patch is a bug
+				// views are expensive, having two around for the same graph is a bug
 				assert((*i)->view() == view);
 
 			} else {
@@ -103,7 +103,7 @@ BreadCrumbs::build(Raul::Path path, SharedPtr<PatchView> view)
 		_breadcrumbs.back()->set_active(true);
 
 	// Rebuild from scratch
-	// Getting here is bad unless absolutely necessary, since the PatchView cache is lost
+	// Getting here is bad unless absolutely necessary, since the GraphView cache is lost
 	} else {
 
 		_full_path = path;
@@ -147,10 +147,10 @@ BreadCrumbs::build(Raul::Path path, SharedPtr<PatchView> view)
  */
 BreadCrumbs::BreadCrumb*
 BreadCrumbs::create_crumb(const Raul::Path&    path,
-                          SharedPtr<PatchView> view)
+                          SharedPtr<GraphView> view)
 {
 	BreadCrumb* but = manage(new BreadCrumb(path,
-			(view && path == view->patch()->path()) ? view : SharedPtr<PatchView>()));
+			(view && path == view->graph()->path()) ? view : SharedPtr<GraphView>()));
 
 	but->signal_toggled().connect(sigc::bind(sigc::mem_fun(
 				this, &BreadCrumbs::breadcrumb_clicked), but));
@@ -168,7 +168,7 @@ BreadCrumbs::breadcrumb_clicked(BreadCrumb* crumb)
 			// Tried to turn off the current active button, bad user, no cookie
 			crumb->set_active(true);
 		} else {
-			signal_patch_selected.emit(crumb->path(), crumb->view());
+			signal_graph_selected.emit(crumb->path(), crumb->view());
 			if (crumb->path() != _active_path)
 				crumb->set_active(false);
 		}
diff --git a/src/gui/BreadCrumbs.hpp b/src/gui/BreadCrumbs.hpp
index 43c7f011..cdb11583 100644
--- a/src/gui/BreadCrumbs.hpp
+++ b/src/gui/BreadCrumbs.hpp
@@ -26,15 +26,15 @@
 #include "raul/Path.hpp"
 #include "raul/SharedPtr.hpp"
 
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 
-#include "PatchView.hpp"
+#include "GraphView.hpp"
 
 namespace Ingen {
 namespace GUI {
 
 /** Collection of breadcrumb buttons forming a path.
- * This doubles as a cache for PatchViews.
+ * This doubles as a cache for GraphViews.
  *
  * \ingroup GUI
  */
@@ -43,17 +43,17 @@ class BreadCrumbs : public Gtk::HBox
 public:
 	explicit BreadCrumbs(App& app);
 
-	SharedPtr<PatchView> view(const Raul::Path& path);
+	SharedPtr<GraphView> view(const Raul::Path& path);
 
-	void build(Raul::Path path, SharedPtr<PatchView> view);
+	void build(Raul::Path path, SharedPtr<GraphView> view);
 
-	sigc::signal<void, const Raul::Path&, SharedPtr<PatchView> > signal_patch_selected;
+	sigc::signal<void, const Raul::Path&, SharedPtr<GraphView> > signal_graph_selected;
 
 private:
 	/** Breadcrumb button.
 	 *
-	 * Each Breadcrumb stores a reference to a PatchView for quick switching.
-	 * So, the amount of allocated PatchViews at a given time is equal to the
+	 * Each Breadcrumb stores a reference to a GraphView for quick switching.
+	 * So, the amount of allocated GraphViews at a given time is equal to the
 	 * number of visible breadcrumbs (which is the perfect cache for GUI
 	 * responsiveness balanced with mem consumption).
 	 *
@@ -62,24 +62,24 @@ private:
 	class BreadCrumb : public Gtk::ToggleButton
 	{
 	public:
-		BreadCrumb(const Raul::Path& path, SharedPtr<PatchView> view = SharedPtr<PatchView>())
+		BreadCrumb(const Raul::Path& path, SharedPtr<GraphView> view = SharedPtr<GraphView>())
 			: _path(path)
 			, _view(view)
 		{
-			assert(!view || view->patch()->path() == path);
+			assert(!view || view->graph()->path() == path);
 			set_border_width(0);
 			set_path(path);
 			set_can_focus(false);
 			show_all();
 		}
 
-		void set_view(SharedPtr<PatchView> view) {
-			assert(!view || view->patch()->path() == _path);
+		void set_view(SharedPtr<GraphView> view) {
+			assert(!view || view->graph()->path() == _path);
 			_view = view;
 		}
 
 		const Raul::Path&    path() const { return _path; }
-		SharedPtr<PatchView> view() const { return _view; }
+		SharedPtr<GraphView> view() const { return _view; }
 
 		void set_path(const Raul::Path& path) {
 			remove();
@@ -89,17 +89,17 @@ private:
 			lab->show();
 			add(*lab);
 
-			if (_view && _view->patch()->path() != path)
+			if (_view && _view->graph()->path() != path)
 				_view.reset();
 		}
 
 	private:
 		Raul::Path           _path;
-		SharedPtr<PatchView> _view;
+		SharedPtr<GraphView> _view;
 	};
 
 	BreadCrumb* create_crumb(const Raul::Path&    path,
-                             SharedPtr<PatchView> view = SharedPtr<PatchView>());
+                             SharedPtr<GraphView> view = SharedPtr<GraphView>());
 
 	void breadcrumb_clicked(BreadCrumb* crumb);
 
diff --git a/src/gui/Configuration.hpp b/src/gui/Configuration.hpp
index c3aec5fc..75c352e9 100644
--- a/src/gui/Configuration.hpp
+++ b/src/gui/Configuration.hpp
@@ -49,8 +49,8 @@ public:
 
 	void apply_settings();
 
-	const std::string& patch_folder()                         { return _patch_folder; }
-	void               set_patch_folder(const std::string& f) { _patch_folder = f; }
+	const std::string& graph_folder()                         { return _graph_folder; }
+	void               set_graph_folder(const std::string& f) { _graph_folder = f; }
 
 	uint32_t get_port_color(const Client::PortModel* p);
 
@@ -62,8 +62,8 @@ public:
 private:
 	App& _app;
 
-	/** Most recent patch folder shown in open dialog */
-	std::string _patch_folder;
+	/** Most recent graph folder shown in open dialog */
+	std::string _graph_folder;
 
 	NameStyle _name_style;
 
diff --git a/src/gui/ConnectWindow.cpp b/src/gui/ConnectWindow.cpp
index ea196175..73874449 100644
--- a/src/gui/ConnectWindow.cpp
+++ b/src/gui/ConnectWindow.cpp
@@ -28,7 +28,7 @@
 #include "ingen/Module.hpp"
 #include "ingen/World.hpp"
 #include "ingen/client/ClientStore.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 #include "ingen/client/ThreadedSigClientInterface.hpp"
 #include "ingen_config.h"
 
@@ -324,7 +324,7 @@ void
 ConnectWindow::on_hide()
 {
 	Gtk::Dialog::on_hide();
-	if (_app->window_factory()->num_open_patch_windows() == 0)
+	if (_app->window_factory()->num_open_graph_windows() == 0)
 		quit();
 }
 
@@ -414,15 +414,15 @@ ConnectWindow::gtk_callback()
 	} else if (_connect_stage == 2) {
 		_app->interface()->get(GraphObject::root_uri());
 		if (_widgets_loaded)
-			_progress_label->set_text(string("Requesting root patch..."));
+			_progress_label->set_text(string("Requesting root graph..."));
 		++_connect_stage;
 	} else if (_connect_stage == 3) {
 		if (_app->store()->size() > 0) {
-			SharedPtr<const PatchModel> root = PtrCast<const PatchModel>(
+			SharedPtr<const GraphModel> root = PtrCast<const GraphModel>(
 				_app->store()->object(Raul::Path("/")));
 			if (root) {
 				set_connected_to(_app->interface());
-				_app->window_factory()->present_patch(root);
+				_app->window_factory()->present_graph(root);
 				_app->interface()->get(Raul::URI("ingen:plugins"));
 				if (_widgets_loaded)
 					_progress_label->set_text(string("Loading plugins..."));
diff --git a/src/gui/Edge.hpp b/src/gui/Edge.hpp
index 0bc22a79..cf1dafe8 100644
--- a/src/gui/Edge.hpp
+++ b/src/gui/Edge.hpp
@@ -28,7 +28,7 @@ namespace Client { class EdgeModel; }
 
 namespace GUI {
 
-/** An Edge in a Patch.
+/** An Edge in a Graph.
  *
  * \ingroup GUI
  */
diff --git a/src/gui/PatchBox.cpp b/src/gui/GraphBox.cpp
index ea3de513..b0847f4a 100644
--- a/src/gui/PatchBox.cpp
+++ b/src/gui/GraphBox.cpp
@@ -25,20 +25,20 @@
 
 #include "ingen/Interface.hpp"
 #include "ingen/client/ClientStore.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 
 #include "App.hpp"
 #include "BreadCrumbs.hpp"
 #include "Configuration.hpp"
 #include "ConnectWindow.hpp"
-#include "LoadPatchWindow.hpp"
+#include "LoadGraphWindow.hpp"
 #include "LoadPluginWindow.hpp"
 #include "MessagesWindow.hpp"
-#include "NewSubpatchWindow.hpp"
-#include "PatchCanvas.hpp"
-#include "PatchTreeWindow.hpp"
-#include "PatchView.hpp"
-#include "PatchWindow.hpp"
+#include "NewSubgraphWindow.hpp"
+#include "GraphCanvas.hpp"
+#include "GraphTreeWindow.hpp"
+#include "GraphView.hpp"
+#include "GraphWindow.hpp"
 #include "ThreadedLoader.hpp"
 #include "WidgetFactory.hpp"
 #include "WindowFactory.hpp"
@@ -55,10 +55,10 @@ using namespace Client;
 namespace GUI {
 
 static const int STATUS_CONTEXT_ENGINE = 0;
-static const int STATUS_CONTEXT_PATCH  = 1;
+static const int STATUS_CONTEXT_GRAPH  = 1;
 static const int STATUS_CONTEXT_HOVER  = 2;
 
-PatchBox::PatchBox(BaseObjectType*                   cobject,
+GraphBox::GraphBox(BaseObjectType*                   cobject,
                    const Glib::RefPtr<Gtk::Builder>& xml)
 	: Gtk::VBox(cobject)
 	, _app(NULL)
@@ -69,106 +69,106 @@ PatchBox::PatchBox(BaseObjectType*                   cobject,
 {
 	property_visible() = false;
 
-	xml->get_widget("patch_win_alignment", _alignment);
-	xml->get_widget("patch_win_status_bar", _status_bar);
-	//xml->get_widget("patch_win_status_bar", _status_bar);
-	//xml->get_widget("patch_open_menuitem", _menu_open);
-	xml->get_widget("patch_import_menuitem", _menu_import);
-	//xml->get_widget("patch_open_into_menuitem", _menu_open_into);
-	xml->get_widget("patch_save_menuitem", _menu_save);
-	xml->get_widget("patch_save_as_menuitem", _menu_save_as);
-	xml->get_widget("patch_draw_menuitem", _menu_draw);
-	xml->get_widget("patch_cut_menuitem", _menu_cut);
-	xml->get_widget("patch_copy_menuitem", _menu_copy);
-	xml->get_widget("patch_paste_menuitem", _menu_paste);
-	xml->get_widget("patch_delete_menuitem", _menu_delete);
-	xml->get_widget("patch_select_all_menuitem", _menu_select_all);
-	xml->get_widget("patch_close_menuitem", _menu_close);
-	xml->get_widget("patch_quit_menuitem", _menu_quit);
-	xml->get_widget("patch_view_control_window_menuitem", _menu_view_control_window);
-	xml->get_widget("patch_view_engine_window_menuitem", _menu_view_engine_window);
-	xml->get_widget("patch_properties_menuitem", _menu_view_patch_properties);
-	xml->get_widget("patch_fullscreen_menuitem", _menu_fullscreen);
-	xml->get_widget("patch_human_names_menuitem", _menu_human_names);
-	xml->get_widget("patch_show_port_names_menuitem", _menu_show_port_names);
-	xml->get_widget("patch_zoom_in_menuitem", _menu_zoom_in);
-	xml->get_widget("patch_zoom_out_menuitem", _menu_zoom_out);
-	xml->get_widget("patch_zoom_normal_menuitem", _menu_zoom_normal);
-	xml->get_widget("patch_status_bar_menuitem", _menu_show_status_bar);
-	xml->get_widget("patch_arrange_menuitem", _menu_arrange);
-	xml->get_widget("patch_view_messages_window_menuitem", _menu_view_messages_window);
-	xml->get_widget("patch_view_patch_tree_window_menuitem", _menu_view_patch_tree_window);
-	xml->get_widget("patch_help_about_menuitem", _menu_help_about);
-	xml->get_widget("patch_documentation_paned", _doc_paned);
-	xml->get_widget("patch_documentation_scrolledwindow", _doc_scrolledwindow);
+	xml->get_widget("graph_win_alignment", _alignment);
+	xml->get_widget("graph_win_status_bar", _status_bar);
+	//xml->get_widget("graph_win_status_bar", _status_bar);
+	//xml->get_widget("graph_open_menuitem", _menu_open);
+	xml->get_widget("graph_import_menuitem", _menu_import);
+	//xml->get_widget("graph_open_into_menuitem", _menu_open_into);
+	xml->get_widget("graph_save_menuitem", _menu_save);
+	xml->get_widget("graph_save_as_menuitem", _menu_save_as);
+	xml->get_widget("graph_draw_menuitem", _menu_draw);
+	xml->get_widget("graph_cut_menuitem", _menu_cut);
+	xml->get_widget("graph_copy_menuitem", _menu_copy);
+	xml->get_widget("graph_paste_menuitem", _menu_paste);
+	xml->get_widget("graph_delete_menuitem", _menu_delete);
+	xml->get_widget("graph_select_all_menuitem", _menu_select_all);
+	xml->get_widget("graph_close_menuitem", _menu_close);
+	xml->get_widget("graph_quit_menuitem", _menu_quit);
+	xml->get_widget("graph_view_control_window_menuitem", _menu_view_control_window);
+	xml->get_widget("graph_view_engine_window_menuitem", _menu_view_engine_window);
+	xml->get_widget("graph_properties_menuitem", _menu_view_graph_properties);
+	xml->get_widget("graph_fullscreen_menuitem", _menu_fullscreen);
+	xml->get_widget("graph_human_names_menuitem", _menu_human_names);
+	xml->get_widget("graph_show_port_names_menuitem", _menu_show_port_names);
+	xml->get_widget("graph_zoom_in_menuitem", _menu_zoom_in);
+	xml->get_widget("graph_zoom_out_menuitem", _menu_zoom_out);
+	xml->get_widget("graph_zoom_normal_menuitem", _menu_zoom_normal);
+	xml->get_widget("graph_status_bar_menuitem", _menu_show_status_bar);
+	xml->get_widget("graph_arrange_menuitem", _menu_arrange);
+	xml->get_widget("graph_view_messages_window_menuitem", _menu_view_messages_window);
+	xml->get_widget("graph_view_graph_tree_window_menuitem", _menu_view_graph_tree_window);
+	xml->get_widget("graph_help_about_menuitem", _menu_help_about);
+	xml->get_widget("graph_documentation_paned", _doc_paned);
+	xml->get_widget("graph_documentation_scrolledwindow", _doc_scrolledwindow);
 
 	_menu_view_control_window->property_sensitive() = false;
 	_menu_import->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_import));
+		sigc::mem_fun(this, &GraphBox::event_import));
 	_menu_save->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_save));
+		sigc::mem_fun(this, &GraphBox::event_save));
 	_menu_save_as->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_save_as));
+		sigc::mem_fun(this, &GraphBox::event_save_as));
 	_menu_draw->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_draw));
+		sigc::mem_fun(this, &GraphBox::event_draw));
 	_menu_copy->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_copy));
+		sigc::mem_fun(this, &GraphBox::event_copy));
 	_menu_paste->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_paste));
+		sigc::mem_fun(this, &GraphBox::event_paste));
 	_menu_delete->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_delete));
+		sigc::mem_fun(this, &GraphBox::event_delete));
 	_menu_select_all->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_select_all));
+		sigc::mem_fun(this, &GraphBox::event_select_all));
 	_menu_close->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_close));
+		sigc::mem_fun(this, &GraphBox::event_close));
 	_menu_quit->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_quit));
+		sigc::mem_fun(this, &GraphBox::event_quit));
 	_menu_fullscreen->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_fullscreen_toggled));
+		sigc::mem_fun(this, &GraphBox::event_fullscreen_toggled));
 	_menu_human_names->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_human_names_toggled));
+		sigc::mem_fun(this, &GraphBox::event_human_names_toggled));
 	_menu_show_status_bar->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_status_bar_toggled));
+		sigc::mem_fun(this, &GraphBox::event_status_bar_toggled));
 	_menu_show_port_names->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_port_names_toggled));
+		sigc::mem_fun(this, &GraphBox::event_port_names_toggled));
 	_menu_arrange->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_arrange));
+		sigc::mem_fun(this, &GraphBox::event_arrange));
 	_menu_quit->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_quit));
+		sigc::mem_fun(this, &GraphBox::event_quit));
 	_menu_zoom_in->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_zoom_in));
+		sigc::mem_fun(this, &GraphBox::event_zoom_in));
 	_menu_zoom_out->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_zoom_out));
+		sigc::mem_fun(this, &GraphBox::event_zoom_out));
 	_menu_zoom_normal->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_zoom_normal));
+		sigc::mem_fun(this, &GraphBox::event_zoom_normal));
 	_menu_view_engine_window->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_show_engine));
-	_menu_view_patch_properties->signal_activate().connect(
-		sigc::mem_fun(this, &PatchBox::event_show_properties));
+		sigc::mem_fun(this, &GraphBox::event_show_engine));
+	_menu_view_graph_properties->signal_activate().connect(
+		sigc::mem_fun(this, &GraphBox::event_show_properties));
 
 	Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get();
 	clipboard->signal_owner_change().connect(
-		sigc::mem_fun(this, &PatchBox::event_clipboard_changed));
+		sigc::mem_fun(this, &GraphBox::event_clipboard_changed));
 }
 
-PatchBox::~PatchBox()
+GraphBox::~GraphBox()
 {
 	delete _breadcrumbs;
 }
 
-SharedPtr<PatchBox>
-PatchBox::create(App& app, SharedPtr<const PatchModel> patch)
+SharedPtr<GraphBox>
+GraphBox::create(App& app, SharedPtr<const GraphModel> graph)
 {
-	PatchBox* result = NULL;
-	Glib::RefPtr<Gtk::Builder> xml = WidgetFactory::create("patch_win");
-	xml->get_widget_derived("patch_win_vbox", result);
+	GraphBox* result = NULL;
+	Glib::RefPtr<Gtk::Builder> xml = WidgetFactory::create("graph_win");
+	xml->get_widget_derived("graph_win_vbox", result);
 	result->init_box(app);
-	result->set_patch(patch, SharedPtr<PatchView>());
-	return SharedPtr<PatchBox>(result);
+	result->set_graph(graph, SharedPtr<GraphView>());
+	return SharedPtr<GraphBox>(result);
 }
 
 void
-PatchBox::init_box(App& app)
+GraphBox::init_box(App& app)
 {
 	_app = &app;
 
@@ -180,41 +180,41 @@ PatchBox::init_box(App& app)
 
 	_menu_view_messages_window->signal_activate().connect(
 		sigc::mem_fun<void>(_app->messages_dialog(), &MessagesWindow::present));
-	_menu_view_patch_tree_window->signal_activate().connect(
-		sigc::mem_fun<void>(_app->patch_tree(), &PatchTreeWindow::present));
+	_menu_view_graph_tree_window->signal_activate().connect(
+		sigc::mem_fun<void>(_app->graph_tree(), &GraphTreeWindow::present));
 
 	_menu_help_about->signal_activate().connect(sigc::hide_return(
 		                                            sigc::mem_fun(_app, &App::show_about)));
 
 	_breadcrumbs = new BreadCrumbs(*_app);
-	_breadcrumbs->signal_patch_selected.connect(
-		sigc::mem_fun(this, &PatchBox::set_patch_from_path));
+	_breadcrumbs->signal_graph_selected.connect(
+		sigc::mem_fun(this, &GraphBox::set_graph_from_path));
 }
 
 void
-PatchBox::set_patch_from_path(const Raul::Path& path, SharedPtr<PatchView> view)
+GraphBox::set_graph_from_path(const Raul::Path& path, SharedPtr<GraphView> view)
 {
 	if (view) {
-		assert(view->patch()->path() == path);
-		_app->window_factory()->present_patch(view->patch(), _window, view);
+		assert(view->graph()->path() == path);
+		_app->window_factory()->present_graph(view->graph(), _window, view);
 	} else {
-		SharedPtr<const PatchModel> model = PtrCast<const PatchModel>(
+		SharedPtr<const GraphModel> model = PtrCast<const GraphModel>(
 			_app->store()->object(path));
 		if (model) {
-			_app->window_factory()->present_patch(model, _window);
+			_app->window_factory()->present_graph(model, _window);
 		}
 	}
 }
 
-/** Sets the patch for this box and initializes everything.
+/** Sets the graph for this box and initializes everything.
  *
  * If @a view is NULL, a new view will be created.
  */
 void
-PatchBox::set_patch(SharedPtr<const PatchModel> patch,
-                    SharedPtr<PatchView>        view)
+GraphBox::set_graph(SharedPtr<const GraphModel> graph,
+                    SharedPtr<GraphView>        view)
 {
-	if (!patch || patch == _patch)
+	if (!graph || graph == _graph)
 		return;
 
 	_enable_signal = false;
@@ -225,16 +225,16 @@ PatchBox::set_patch(SharedPtr<const PatchModel> patch,
 	_entered_connection.disconnect();
 	_left_connection.disconnect();
 
-	_status_bar->pop(STATUS_CONTEXT_PATCH);
+	_status_bar->pop(STATUS_CONTEXT_GRAPH);
 
-	_patch = patch;
+	_graph = graph;
 	_view  = view;
 
 	if (!_view)
-		_view = _breadcrumbs->view(patch->path());
+		_view = _breadcrumbs->view(graph->path());
 
 	if (!_view)
-		_view = PatchView::create(*_app, patch);
+		_view = GraphView::create(*_app, graph);
 
 	assert(_view);
 
@@ -252,38 +252,38 @@ PatchBox::set_patch(SharedPtr<const PatchModel> patch,
 	_view->breadcrumb_container()->add(*_breadcrumbs);
 	_view->breadcrumb_container()->show();
 
-	_breadcrumbs->build(patch->path(), _view);
+	_breadcrumbs->build(graph->path(), _view);
 	_breadcrumbs->show();
 
 	_menu_view_control_window->property_sensitive() = false;
 
-	for (BlockModel::Ports::const_iterator p = patch->ports().begin();
-	     p != patch->ports().end(); ++p) {
+	for (BlockModel::Ports::const_iterator p = graph->ports().begin();
+	     p != graph->ports().end(); ++p) {
 		if (_app->can_control(p->get())) {
 			_menu_view_control_window->property_sensitive() = true;
 			break;
 		}
 	}
 
-	new_port_connection = patch->signal_new_port().connect(
-		sigc::mem_fun(this, &PatchBox::patch_port_added));
-	removed_port_connection = patch->signal_removed_port().connect(
-		sigc::mem_fun(this, &PatchBox::patch_port_removed));
+	new_port_connection = graph->signal_new_port().connect(
+		sigc::mem_fun(this, &GraphBox::graph_port_added));
+	removed_port_connection = graph->signal_removed_port().connect(
+		sigc::mem_fun(this, &GraphBox::graph_port_removed));
 
 	show();
 	_alignment->show_all();
 	hide_documentation();
 
 	_view->signal_object_entered.connect(
-		sigc::mem_fun(this, &PatchBox::object_entered));
+		sigc::mem_fun(this, &GraphBox::object_entered));
 	_view->signal_object_left.connect(
-		sigc::mem_fun(this, &PatchBox::object_left));
+		sigc::mem_fun(this, &GraphBox::object_left));
 
 	_enable_signal = true;
 }
 
 void
-PatchBox::patch_port_added(SharedPtr<const PortModel> port)
+GraphBox::graph_port_added(SharedPtr<const PortModel> port)
 {
 	if (port->is_input() && _app->can_control(port.get())) {
 		_menu_view_control_window->property_sensitive() = true;
@@ -291,13 +291,13 @@ PatchBox::patch_port_added(SharedPtr<const PortModel> port)
 }
 
 void
-PatchBox::patch_port_removed(SharedPtr<const PortModel> port)
+GraphBox::graph_port_removed(SharedPtr<const PortModel> port)
 {
 	if (!(port->is_input() && _app->can_control(port.get())))
 		return;
 
-	for (BlockModel::Ports::const_iterator i = _patch->ports().begin();
-	     i != _patch->ports().end(); ++i) {
+	for (BlockModel::Ports::const_iterator i = _graph->ports().begin();
+	     i != _graph->ports().end(); ++i) {
 		if ((*i)->is_input() && _app->can_control(i->get())) {
 			_menu_view_control_window->property_sensitive() = true;
 			return;
@@ -308,7 +308,7 @@ PatchBox::patch_port_removed(SharedPtr<const PortModel> port)
 }
 
 void
-PatchBox::show_documentation(const std::string& doc, bool html)
+GraphBox::show_documentation(const std::string& doc, bool html)
 {
 #ifdef HAVE_WEBKIT
 	WebKitWebView* view = WEBKIT_WEB_VIEW(webkit_web_view_new());
@@ -329,7 +329,7 @@ PatchBox::show_documentation(const std::string& doc, bool html)
 }
 
 void
-PatchBox::hide_documentation()
+GraphBox::hide_documentation()
 {
 	_doc_scrolledwindow->remove();
 	_doc_scrolledwindow->hide();
@@ -337,7 +337,7 @@ PatchBox::hide_documentation()
 }
 
 void
-PatchBox::show_status(const ObjectModel* model)
+GraphBox::show_status(const ObjectModel* model)
 {
 	std::stringstream msg;
 	msg << model->path();
@@ -357,7 +357,7 @@ PatchBox::show_status(const ObjectModel* model)
 }
 
 void
-PatchBox::show_port_status(const PortModel* port, const Raul::Atom& value)
+GraphBox::show_port_status(const PortModel* port, const Raul::Atom& value)
 {
 	std::stringstream msg;
 	msg << port->path();
@@ -381,61 +381,61 @@ PatchBox::show_port_status(const PortModel* port, const Raul::Atom& value)
 }
 
 void
-PatchBox::object_entered(const ObjectModel* model)
+GraphBox::object_entered(const ObjectModel* model)
 {
 	show_status(model);
 }
 
 void
-PatchBox::object_left(const ObjectModel* model)
+GraphBox::object_left(const ObjectModel* model)
 {
-	_status_bar->pop(STATUS_CONTEXT_PATCH);
+	_status_bar->pop(STATUS_CONTEXT_GRAPH);
 	_status_bar->pop(STATUS_CONTEXT_HOVER);
 }
 
 void
-PatchBox::event_show_engine()
+GraphBox::event_show_engine()
 {
-	if (_patch)
+	if (_graph)
 		_app->connect_window()->show();
 }
 
 void
-PatchBox::event_clipboard_changed(GdkEventOwnerChange* ev)
+GraphBox::event_clipboard_changed(GdkEventOwnerChange* ev)
 {
 	Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get();
 	_menu_paste->set_sensitive(clipboard->wait_is_text_available());
 }
 
 void
-PatchBox::event_show_properties()
+GraphBox::event_show_properties()
 {
-	_app->window_factory()->present_properties(_patch);
+	_app->window_factory()->present_properties(_graph);
 }
 
 void
-PatchBox::event_import()
+GraphBox::event_import()
 {
-	_app->window_factory()->present_load_patch(_patch);
+	_app->window_factory()->present_load_graph(_graph);
 }
 
 void
-PatchBox::event_save()
+GraphBox::event_save()
 {
-	const Raul::Atom& document = _patch->get_property(_app->uris().ingen_document);
+	const Raul::Atom& document = _graph->get_property(_app->uris().ingen_document);
 	if (!document.is_valid() || document.type() != _app->uris().forge.URI) {
 		event_save_as();
 	} else {
-		_app->loader()->save_patch(_patch, document.get_uri());
+		_app->loader()->save_graph(_graph, document.get_uri());
 		_status_bar->push(
-			(boost::format("Saved %1% to %2%") % _patch->path().c_str()
+			(boost::format("Saved %1% to %2%") % _graph->path().c_str()
 			 % document.get_uri()).str(),
-			STATUS_CONTEXT_PATCH);
+			STATUS_CONTEXT_GRAPH);
 	}
 }
 
 int
-PatchBox::message_dialog(const Glib::ustring& message,
+GraphBox::message_dialog(const Glib::ustring& message,
                          const Glib::ustring& secondary_text,
                          Gtk::MessageType     type,
                          Gtk::ButtonsType     buttons)
@@ -449,11 +449,11 @@ PatchBox::message_dialog(const Glib::ustring& message,
 }
 
 void
-PatchBox::event_save_as()
+GraphBox::event_save_as()
 {
 	const URIs& uris = _app->uris();
 	while (true) {
-		Gtk::FileChooserDialog dialog("Save Patch", Gtk::FILE_CHOOSER_ACTION_SAVE);
+		Gtk::FileChooserDialog dialog("Save Graph", Gtk::FILE_CHOOSER_ACTION_SAVE);
 		if (_window) {
 			dialog.set_transient_for(*_window);
 		}
@@ -468,11 +468,11 @@ PatchBox::event_save_as()
 		dialog.set_filter(filt);
 
 		// Set current folder to most sensible default
-		const Raul::Atom& document = _patch->get_property(uris.ingen_document);
+		const Raul::Atom& document = _graph->get_property(uris.ingen_document);
 		if (document.type() == uris.forge.URI)
 			dialog.set_uri(document.get_uri());
-		else if (_app->configuration()->patch_folder().length() > 0)
-			dialog.set_current_folder(_app->configuration()->patch_folder());
+		else if (_app->configuration()->graph_folder().length() > 0)
+			dialog.set_current_folder(_app->configuration()->graph_folder());
 
 		if (dialog.run() != Gtk::RESPONSE_OK)
 			break;
@@ -485,7 +485,7 @@ PatchBox::event_save_as()
 			basename += ".ingen";
 		} else if (filename.substr(filename.length() - 10) != ".ingen") {
 			message_dialog(
-				"<b>Ingen patches must be saved to Ingen bundles (*.ingen).</b>",
+				"<b>Ingen graphs must be saved to Ingen bundles (*.ingen).</b>",
 				"", Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK);
 			continue;
 		}
@@ -500,7 +500,7 @@ PatchBox::event_save_as()
 			continue;
 		}
 
-		//_patch->set_property(uris.lv2_symbol, Atom(symbol.c_str()));
+		//_graph->set_property(uris.lv2_symbol, Atom(symbol.c_str()));
 
 		bool confirm = true;
 		if (Glib::file_test(filename, Glib::FILE_TEST_IS_DIR)) {
@@ -535,24 +535,24 @@ PatchBox::event_save_as()
 
 		if (confirm) {
 			const Glib::ustring uri = Glib::filename_to_uri(filename);
-			_app->loader()->save_patch(_patch, uri);
-			const_cast<PatchModel*>(_patch.get())->set_property(
+			_app->loader()->save_graph(_graph, uri);
+			const_cast<GraphModel*>(_graph.get())->set_property(
 				uris.ingen_document,
 				_app->forge().alloc_uri(uri.c_str()),
 				Resource::EXTERNAL);
 			_status_bar->push(
-				(boost::format("Saved %1% to %2%") % _patch->path().c_str()
+				(boost::format("Saved %1% to %2%") % _graph->path().c_str()
 				 % filename).str(),
-				STATUS_CONTEXT_PATCH);
+				STATUS_CONTEXT_GRAPH);
 		}
 
-		_app->configuration()->set_patch_folder(dialog.get_current_folder());
+		_app->configuration()->set_graph_folder(dialog.get_current_folder());
 		break;
 	}
 }
 
 void
-PatchBox::event_draw()
+GraphBox::event_draw()
 {
 	Gtk::FileChooserDialog dialog("Draw to DOT", Gtk::FILE_CHOOSER_ACTION_SAVE);
 	if (_window) {
@@ -582,80 +582,80 @@ PatchBox::event_draw()
 			_view->canvas()->export_dot(filename.c_str());
 			_status_bar->push(
 				(boost::format("Rendered %1% to %2%")
-				 % _patch->path() % filename).str(),
-				STATUS_CONTEXT_PATCH);
+				 % _graph->path() % filename).str(),
+				STATUS_CONTEXT_GRAPH);
 		}
 	}
 }
 
 void
-PatchBox::event_copy()
+GraphBox::event_copy()
 {
 	if (_view)
 		_view->canvas()->copy_selection();
 }
 
 void
-PatchBox::event_paste()
+GraphBox::event_paste()
 {
 	if (_view)
 		_view->canvas()->paste();
 }
 
 void
-PatchBox::event_delete()
+GraphBox::event_delete()
 {
 	if (_view)
 		_view->canvas()->destroy_selection();
 }
 
 void
-PatchBox::event_select_all()
+GraphBox::event_select_all()
 {
 	if (_view)
 		_view->canvas()->select_all();
 }
 
 void
-PatchBox::event_close()
+GraphBox::event_close()
 {
 	if (_window) {
-		_app->window_factory()->remove_patch_window(_window);
+		_app->window_factory()->remove_graph_window(_window);
 	}
 }
 
 void
-PatchBox::event_quit()
+GraphBox::event_quit()
 {
 	_app->quit(_window);
 }
 
 void
-PatchBox::event_zoom_in()
+GraphBox::event_zoom_in()
 {
 	_view->canvas()->set_font_size(_view->canvas()->get_font_size() + 1.0);
 }
 
 void
-PatchBox::event_zoom_out()
+GraphBox::event_zoom_out()
 {
 	_view->canvas()->set_font_size(_view->canvas()->get_font_size() - 1.0);
 }
 
 void
-PatchBox::event_zoom_normal()
+GraphBox::event_zoom_normal()
 {
 	_view->canvas()->set_scale(1.0, _view->canvas()->get_default_font_size());
 }
 
 void
-PatchBox::event_arrange()
+GraphBox::event_arrange()
 {
 	_view->canvas()->arrange();
 }
 
 void
-PatchBox::event_fullscreen_toggled()
+GraphBox::event_fullscreen_toggled()
 {
 	// FIXME: ugh, use GTK signals to track state and know for sure
 	static bool is_fullscreen = false;
@@ -672,7 +672,7 @@ PatchBox::event_fullscreen_toggled()
 }
 
 void
-PatchBox::event_status_bar_toggled()
+GraphBox::event_status_bar_toggled()
 {
 	if (_menu_show_status_bar->get_active())
 		_status_bar->show();
@@ -681,7 +681,7 @@ PatchBox::event_status_bar_toggled()
 }
 
 void
-PatchBox::event_human_names_toggled()
+GraphBox::event_human_names_toggled()
 {
 	_view->canvas()->show_human_names(_menu_human_names->get_active());
 	if (_menu_human_names->get_active())
@@ -691,7 +691,7 @@ PatchBox::event_human_names_toggled()
 }
 
 void
-PatchBox::event_port_names_toggled()
+GraphBox::event_port_names_toggled()
 {
 	if (_menu_show_port_names->get_active()) {
 		_view->canvas()->set_direction(GANV_DIRECTION_RIGHT);
diff --git a/src/gui/PatchBox.hpp b/src/gui/GraphBox.hpp
index f69f98b7..e8ee3d8b 100644
--- a/src/gui/PatchBox.hpp
+++ b/src/gui/GraphBox.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_GUI_PATCH_BOX_HPP
-#define INGEN_GUI_PATCH_BOX_HPP
+#ifndef INGEN_GUI_GRAPH_BOX_HPP
+#define INGEN_GUI_GRAPH_BOX_HPP
 
 #include <string>
 
@@ -40,7 +40,7 @@ class Path;
 namespace Ingen {
 
 namespace Client {
-class PatchModel;
+class GraphModel;
 class PortModel;
 class ObjectModel;
 }
@@ -48,52 +48,52 @@ class ObjectModel;
 namespace GUI {
 
 class BreadCrumbs;
-class LoadPatchBox;
+class LoadGraphBox;
 class LoadPluginWindow;
-class NewSubpatchWindow;
-class PatchDescriptionWindow;
-class PatchView;
-class PatchWindow;
-class SubpatchModule;
+class NewSubgraphWindow;
+class GraphDescriptionWindow;
+class GraphView;
+class GraphWindow;
+class SubgraphModule;
 
-/** A window for a patch.
+/** A window for a graph.
  *
  * \ingroup GUI
  */
-class PatchBox : public Gtk::VBox
+class GraphBox : public Gtk::VBox
 {
 public:
-	PatchBox(BaseObjectType*                   cobject,
+	GraphBox(BaseObjectType*                   cobject,
 	         const Glib::RefPtr<Gtk::Builder>& xml);
-	~PatchBox();
+	~GraphBox();
 
-	static SharedPtr<PatchBox> create(
-		App& app, SharedPtr<const Client::PatchModel> patch);
+	static SharedPtr<GraphBox> create(
+		App& app, SharedPtr<const Client::GraphModel> graph);
 
 	void init_box(App& app);
 
-	void set_patch(SharedPtr<const Client::PatchModel> pc,
-	               SharedPtr<PatchView>                view);
+	void set_graph(SharedPtr<const Client::GraphModel> graph,
+	               SharedPtr<GraphView>                view);
 
-	void set_window(PatchWindow* win) { _window = win; }
+	void set_window(GraphWindow* win) { _window = win; }
 
 	void show_documentation(const std::string& doc, bool html);
 	void hide_documentation();
 
-	SharedPtr<const Client::PatchModel> patch() const { return _patch; }
-	SharedPtr<PatchView>                view()  const { return _view; }
+	SharedPtr<const Client::GraphModel> graph() const { return _graph; }
+	SharedPtr<GraphView>                view()  const { return _view; }
 
 	void show_port_status(const Client::PortModel* model,
 	                      const Raul::Atom&        value);
 
-	void set_patch_from_path(const Raul::Path& path, SharedPtr<PatchView> view);
+	void set_graph_from_path(const Raul::Path& path, SharedPtr<GraphView> view);
 
 	void object_entered(const Client::ObjectModel* model);
 	void object_left(const Client::ObjectModel* model);
 
 private:
-	void patch_port_added(SharedPtr<const Client::PortModel> port);
-	void patch_port_removed(SharedPtr<const Client::PortModel> port);
+	void graph_port_added(SharedPtr<const Client::PortModel> port);
+	void graph_port_removed(SharedPtr<const Client::PortModel> port);
 	void show_status(const Client::ObjectModel* model);
 
 	int message_dialog(const Glib::ustring& message,
@@ -124,9 +124,9 @@ private:
 	void event_clipboard_changed(GdkEventOwnerChange* ev);
 
 	App*                                _app;
-	SharedPtr<const Client::PatchModel> _patch;
-	SharedPtr<PatchView>                _view;
-	PatchWindow*                        _window;
+	SharedPtr<const Client::GraphModel> _graph;
+	SharedPtr<GraphView>                _view;
+	GraphWindow*                        _window;
 
 	sigc::connection new_port_connection;
 	sigc::connection removed_port_connection;
@@ -153,9 +153,9 @@ private:
 	Gtk::MenuItem*      _menu_arrange;
 	Gtk::MenuItem*      _menu_view_engine_window;
 	Gtk::MenuItem*      _menu_view_control_window;
-	Gtk::MenuItem*      _menu_view_patch_properties;
+	Gtk::MenuItem*      _menu_view_graph_properties;
 	Gtk::MenuItem*      _menu_view_messages_window;
-	Gtk::MenuItem*      _menu_view_patch_tree_window;
+	Gtk::MenuItem*      _menu_view_graph_tree_window;
 	Gtk::MenuItem*      _menu_help_about;
 
 	Gtk::VBox*          _vbox;
@@ -179,4 +179,4 @@ private:
 } // namespace GUI
 } // namespace Ingen
 
-#endif // INGEN_GUI_PATCH_BOX_HPP
+#endif // INGEN_GUI_GRAPH_BOX_HPP
diff --git a/src/gui/PatchCanvas.cpp b/src/gui/GraphCanvas.cpp
index d680a9b8..e6fe3db7 100644
--- a/src/gui/PatchCanvas.cpp
+++ b/src/gui/GraphCanvas.cpp
@@ -31,21 +31,21 @@
 #include "ingen/World.hpp"
 #include "ingen/client/ClientStore.hpp"
 #include "ingen/client/BlockModel.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 #include "ingen/client/PluginModel.hpp"
 #include "ingen/serialisation/Serialiser.hpp"
 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
 
 #include "App.hpp"
 #include "Edge.hpp"
+#include "GraphCanvas.hpp"
+#include "GraphPortModule.hpp"
+#include "GraphWindow.hpp"
 #include "LoadPluginWindow.hpp"
-#include "NewSubpatchWindow.hpp"
+#include "NewSubgraphWindow.hpp"
 #include "NodeModule.hpp"
-#include "PatchCanvas.hpp"
-#include "PatchPortModule.hpp"
-#include "PatchWindow.hpp"
 #include "Port.hpp"
-#include "SubpatchModule.hpp"
+#include "SubgraphModule.hpp"
 #include "ThreadedLoader.hpp"
 #include "WidgetFactory.hpp"
 #include "WindowFactory.hpp"
@@ -62,13 +62,13 @@ using namespace Client;
 
 namespace GUI {
 
-PatchCanvas::PatchCanvas(App&                        app,
-                         SharedPtr<const PatchModel> patch,
+GraphCanvas::GraphCanvas(App&                        app,
+                         SharedPtr<const GraphModel> graph,
                          int                         width,
                          int                         height)
 	: Canvas(width, height)
 	, _app(app)
-	, _patch(patch)
+	, _graph(graph)
 	, _auto_position_count(0)
 	, _last_click_x(0)
 	, _last_click_y(0)
@@ -89,79 +89,79 @@ PatchCanvas::PatchCanvas(App&                        app,
 	xml->get_widget("canvas_menu_add_event_input", _menu_add_event_input);
 	xml->get_widget("canvas_menu_add_event_output", _menu_add_event_output);
 	xml->get_widget("canvas_menu_load_plugin", _menu_load_plugin);
-	xml->get_widget("canvas_menu_load_patch", _menu_load_patch);
-	xml->get_widget("canvas_menu_new_patch", _menu_new_patch);
+	xml->get_widget("canvas_menu_load_graph", _menu_load_graph);
+	xml->get_widget("canvas_menu_new_graph", _menu_new_graph);
 	xml->get_widget("canvas_menu_edit", _menu_edit);
 
 	const URIs& uris = _app.uris();
 
 	// Add port menu items
 	_menu_add_audio_input->signal_activate().connect(
-		sigc::bind(sigc::mem_fun(this, &PatchCanvas::menu_add_port),
+		sigc::bind(sigc::mem_fun(this, &GraphCanvas::menu_add_port),
 		           "audio_in", "Audio In", uris.lv2_AudioPort, false));
 	_menu_add_audio_output->signal_activate().connect(
-		sigc::bind(sigc::mem_fun(this, &PatchCanvas::menu_add_port),
+		sigc::bind(sigc::mem_fun(this, &GraphCanvas::menu_add_port),
 		           "audio_out", "Audio Out", uris.lv2_AudioPort, true));
 	_menu_add_control_input->signal_activate().connect(
-		sigc::bind(sigc::mem_fun(this, &PatchCanvas::menu_add_port),
+		sigc::bind(sigc::mem_fun(this, &GraphCanvas::menu_add_port),
 		           "control_in", "Control In", uris.lv2_ControlPort, false));
 	_menu_add_control_output->signal_activate().connect(
-		sigc::bind(sigc::mem_fun(this, &PatchCanvas::menu_add_port),
+		sigc::bind(sigc::mem_fun(this, &GraphCanvas::menu_add_port),
 		           "control_out", "Control Out", uris.lv2_ControlPort, true));
 	_menu_add_event_input->signal_activate().connect(
-		sigc::bind(sigc::mem_fun(this, &PatchCanvas::menu_add_port),
+		sigc::bind(sigc::mem_fun(this, &GraphCanvas::menu_add_port),
 		           "event_in", "Event In", uris.atom_AtomPort, false));
 	_menu_add_event_output->signal_activate().connect(
-		sigc::bind(sigc::mem_fun(this, &PatchCanvas::menu_add_port),
+		sigc::bind(sigc::mem_fun(this, &GraphCanvas::menu_add_port),
 		           "event_out", "Event Out", uris.atom_AtomPort, true));
 
 	signal_event.connect(
-		sigc::mem_fun(this, &PatchCanvas::on_event));
+		sigc::mem_fun(this, &GraphCanvas::on_event));
 	signal_connect.connect(
-		sigc::mem_fun(this, &PatchCanvas::connect));
+		sigc::mem_fun(this, &GraphCanvas::connect));
 	signal_disconnect.connect(
-		sigc::mem_fun(this, &PatchCanvas::disconnect));
+		sigc::mem_fun(this, &GraphCanvas::disconnect));
 
 	// Connect to model signals to track state
-	_patch->signal_new_block().connect(
-		sigc::mem_fun(this, &PatchCanvas::add_block));
-	_patch->signal_removed_block().connect(
-		sigc::mem_fun(this, &PatchCanvas::remove_block));
-	_patch->signal_new_port().connect(
-		sigc::mem_fun(this, &PatchCanvas::add_port));
-	_patch->signal_removed_port().connect(
-		sigc::mem_fun(this, &PatchCanvas::remove_port));
-	_patch->signal_new_edge().connect(
-		sigc::mem_fun(this, &PatchCanvas::connection));
-	_patch->signal_removed_edge().connect(
-		sigc::mem_fun(this, &PatchCanvas::disconnection));
+	_graph->signal_new_block().connect(
+		sigc::mem_fun(this, &GraphCanvas::add_block));
+	_graph->signal_removed_block().connect(
+		sigc::mem_fun(this, &GraphCanvas::remove_block));
+	_graph->signal_new_port().connect(
+		sigc::mem_fun(this, &GraphCanvas::add_port));
+	_graph->signal_removed_port().connect(
+		sigc::mem_fun(this, &GraphCanvas::remove_port));
+	_graph->signal_new_edge().connect(
+		sigc::mem_fun(this, &GraphCanvas::connection));
+	_graph->signal_removed_edge().connect(
+		sigc::mem_fun(this, &GraphCanvas::disconnection));
 
 	_app.store()->signal_new_plugin().connect(
-		sigc::mem_fun(this, &PatchCanvas::add_plugin));
+		sigc::mem_fun(this, &GraphCanvas::add_plugin));
 
 	// Connect widget signals to do things
 	_menu_load_plugin->signal_activate().connect(
-		sigc::mem_fun(this, &PatchCanvas::menu_load_plugin));
-	_menu_load_patch->signal_activate().connect(
-		sigc::mem_fun(this, &PatchCanvas::menu_load_patch));
-	_menu_new_patch->signal_activate().connect(
-		sigc::mem_fun(this, &PatchCanvas::menu_new_patch));
+		sigc::mem_fun(this, &GraphCanvas::menu_load_plugin));
+	_menu_load_graph->signal_activate().connect(
+		sigc::mem_fun(this, &GraphCanvas::menu_load_graph));
+	_menu_new_graph->signal_activate().connect(
+		sigc::mem_fun(this, &GraphCanvas::menu_new_graph));
 }
 
 void
-PatchCanvas::show_menu(bool position, unsigned button, uint32_t time)
+GraphCanvas::show_menu(bool position, unsigned button, uint32_t time)
 {
 	if (!_internal_menu)
 		build_menus();
 
 	if (position)
-		_menu->popup(sigc::mem_fun(this, &PatchCanvas::auto_menu_position), button, time);
+		_menu->popup(sigc::mem_fun(this, &GraphCanvas::auto_menu_position), button, time);
 	else
 		_menu->popup(button, time);
 }
 
 void
-PatchCanvas::build_menus()
+GraphCanvas::build_menus()
 {
 	// Build (or clear existing) internal plugin menu
 	if (_internal_menu) {
@@ -202,7 +202,7 @@ PatchCanvas::build_menus()
  * @a plugin class into @a menu
  */
 size_t
-PatchCanvas::build_plugin_class_menu(
+GraphCanvas::build_plugin_class_menu(
 	Gtk::Menu*               menu,
 	const LilvPluginClass*   plugin_class,
 	const LilvPluginClasses* classes,
@@ -253,7 +253,7 @@ PatchCanvas::build_plugin_class_menu(
 }
 
 void
-PatchCanvas::build_plugin_menu()
+GraphCanvas::build_plugin_menu()
 {
 	if (_plugin_menu) {
 		_plugin_menu->items().clear();
@@ -285,26 +285,26 @@ PatchCanvas::build_plugin_menu()
 }
 
 void
-PatchCanvas::build()
+GraphCanvas::build()
 {
-	const Store::const_range kids = _app.store()->children_range(_patch);
+	const Store::const_range kids = _app.store()->children_range(_graph);
 
 	// Create modules for blocks
 	for (Store::const_iterator i = kids.first; i != kids.second; ++i) {
 		SharedPtr<BlockModel> block = PtrCast<BlockModel>(i->second);
-		if (block && block->parent() == _patch)
+		if (block && block->parent() == _graph)
 			add_block(block);
 	}
 
 	// Create pseudo modules for ports (ports on this canvas, not on our module)
-	for (BlockModel::Ports::const_iterator i = _patch->ports().begin();
-	     i != _patch->ports().end(); ++i) {
+	for (BlockModel::Ports::const_iterator i = _graph->ports().begin();
+	     i != _graph->ports().end(); ++i) {
 		add_port(*i);
 	}
 
 	// Create edges
-	for (PatchModel::Edges::const_iterator i = _patch->edges().begin();
-	     i != _patch->edges().end(); ++i) {
+	for (GraphModel::Edges::const_iterator i = _graph->edges().begin();
+	     i != _graph->edges().end(); ++i) {
 		connection(PtrCast<EdgeModel>(i->second));
 	}
 }
@@ -319,33 +319,33 @@ show_module_human_names(GanvNode* node, void* data)
 		if (nmod)
 			nmod->show_human_names(b);
 
-		PatchPortModule* pmod = dynamic_cast<PatchPortModule*>(module);
+		GraphPortModule* pmod = dynamic_cast<GraphPortModule*>(module);
 		if (pmod)
 			pmod->show_human_names(b);
 	}
 }
 void
-PatchCanvas::show_human_names(bool b)
+GraphCanvas::show_human_names(bool b)
 {
 	_human_names = b;
 	for_each_node(show_module_human_names, &b);
 }
 
 void
-PatchCanvas::show_port_names(bool b)
+GraphCanvas::show_port_names(bool b)
 {
 	ganv_canvas_set_direction(gobj(), b ? GANV_DIRECTION_RIGHT : GANV_DIRECTION_DOWN);
 }
 
 void
-PatchCanvas::add_plugin(SharedPtr<PluginModel> p)
+GraphCanvas::add_plugin(SharedPtr<PluginModel> p)
 {
 	typedef ClassMenus::iterator iterator;
 	if (_internal_menu && p->type() == Plugin::Internal) {
 		_internal_menu->items().push_back(
 			Gtk::Menu_Helpers::MenuElem(
 				p->human_name(),
-				sigc::bind(sigc::mem_fun(this, &PatchCanvas::load_plugin), p)));
+				sigc::bind(sigc::mem_fun(this, &GraphCanvas::load_plugin), p)));
 	} else if (_plugin_menu && p->type() == Plugin::LV2 && p->lilv_plugin()) {
 		if (lilv_plugin_is_replaced(p->lilv_plugin())) {
 			//info << (boost::format("[Menu] LV2 plugin <%s> hidden") % p->uri()) << endl;
@@ -365,7 +365,7 @@ PatchCanvas::add_plugin(SharedPtr<PluginModel> p)
 			_classless_menu->items().push_back(
 				Gtk::Menu_Helpers::MenuElem(
 					p->human_name(),
-					sigc::bind(sigc::mem_fun(this, &PatchCanvas::load_plugin), p)));
+					sigc::bind(sigc::mem_fun(this, &GraphCanvas::load_plugin), p)));
 			if (!_classless_menu->is_visible())
 				_classless_menu->show();
 		} else {
@@ -377,12 +377,12 @@ PatchCanvas::add_plugin(SharedPtr<PluginModel> p)
 					menu->items().push_back(
 						Gtk::Menu_Helpers::ImageMenuElem(
 							p->human_name(), *image,
-							sigc::bind(sigc::mem_fun(this, &PatchCanvas::load_plugin), p)));
+							sigc::bind(sigc::mem_fun(this, &GraphCanvas::load_plugin), p)));
 				} else {
 					menu->items().push_back(
 						Gtk::Menu_Helpers::MenuElem(
 							p->human_name(),
-							sigc::bind(sigc::mem_fun(this, &PatchCanvas::load_plugin), p)));
+							sigc::bind(sigc::mem_fun(this, &GraphCanvas::load_plugin), p)));
 				}
 				if (!i->second.item->is_visible())
 					i->second.item->show();
@@ -392,12 +392,12 @@ PatchCanvas::add_plugin(SharedPtr<PluginModel> p)
 }
 
 void
-PatchCanvas::add_block(SharedPtr<const BlockModel> bm)
+GraphCanvas::add_block(SharedPtr<const BlockModel> bm)
 {
-	SharedPtr<const PatchModel> pm = PtrCast<const PatchModel>(bm);
+	SharedPtr<const GraphModel> pm = PtrCast<const GraphModel>(bm);
 	NodeModule*                 module;
 	if (pm) {
-		module = SubpatchModule::create(*this, pm, _human_names);
+		module = SubgraphModule::create(*this, pm, _human_names);
 	} else {
 		module = NodeModule::create(*this, bm, _human_names);
 		//const PluginModel* plugm = dynamic_cast<const PluginModel*>(nm->plugin());
@@ -413,7 +413,7 @@ PatchCanvas::add_block(SharedPtr<const BlockModel> bm)
 }
 
 void
-PatchCanvas::remove_block(SharedPtr<const BlockModel> bm)
+GraphCanvas::remove_block(SharedPtr<const BlockModel> bm)
 {
 	Views::iterator i = _views.find(bm);
 
@@ -428,19 +428,19 @@ PatchCanvas::remove_block(SharedPtr<const BlockModel> bm)
 }
 
 void
-PatchCanvas::add_port(SharedPtr<const PortModel> pm)
+GraphCanvas::add_port(SharedPtr<const PortModel> pm)
 {
-	PatchPortModule* view = PatchPortModule::create(*this, pm, _human_names);
+	GraphPortModule* view = GraphPortModule::create(*this, pm, _human_names);
 	_views.insert(std::make_pair(pm, view));
 	view->show();
 }
 
 void
-PatchCanvas::remove_port(SharedPtr<const PortModel> pm)
+GraphCanvas::remove_port(SharedPtr<const PortModel> pm)
 {
 	Views::iterator i = _views.find(pm);
 
-	// Port on this patch
+	// Port on this graph
 	if (i != _views.end()) {
 		delete i->second;
 		_views.erase(i);
@@ -454,13 +454,13 @@ PatchCanvas::remove_port(SharedPtr<const PortModel> pm)
 }
 
 Ganv::Port*
-PatchCanvas::get_port_view(SharedPtr<PortModel> port)
+GraphCanvas::get_port_view(SharedPtr<PortModel> port)
 {
 	Ganv::Module* module = _views[port];
 
-	// Port on this patch
+	// Port on this graph
 	if (module) {
-		PatchPortModule* ppm = dynamic_cast<PatchPortModule*>(module);
+		GraphPortModule* ppm = dynamic_cast<GraphPortModule*>(module);
 		return ppm
 			? *ppm->begin()
 			: dynamic_cast<Ganv::Port*>(module);
@@ -480,7 +480,7 @@ PatchCanvas::get_port_view(SharedPtr<PortModel> port)
 }
 
 void
-PatchCanvas::connection(SharedPtr<const EdgeModel> cm)
+GraphCanvas::connection(SharedPtr<const EdgeModel> cm)
 {
 	Ganv::Port* const tail = get_port_view(cm->tail());
 	Ganv::Port* const head = get_port_view(cm->head());
@@ -494,7 +494,7 @@ PatchCanvas::connection(SharedPtr<const EdgeModel> cm)
 }
 
 void
-PatchCanvas::disconnection(SharedPtr<const EdgeModel> cm)
+GraphCanvas::disconnection(SharedPtr<const EdgeModel> cm)
 {
 	Ganv::Port* const src = get_port_view(cm->tail());
 	Ganv::Port* const dst = get_port_view(cm->head());
@@ -508,7 +508,7 @@ PatchCanvas::disconnection(SharedPtr<const EdgeModel> cm)
 }
 
 void
-PatchCanvas::connect(Ganv::Node* tail,
+GraphCanvas::connect(Ganv::Node* tail,
                      Ganv::Node* head)
 {
 	const Ingen::GUI::Port* const src
@@ -524,7 +524,7 @@ PatchCanvas::connect(Ganv::Node* tail,
 }
 
 void
-PatchCanvas::disconnect(Ganv::Node* tail,
+GraphCanvas::disconnect(Ganv::Node* tail,
                         Ganv::Node* head)
 {
 	const Ingen::GUI::Port* const t = dynamic_cast<Ingen::GUI::Port*>(tail);
@@ -534,7 +534,7 @@ PatchCanvas::disconnect(Ganv::Node* tail,
 }
 
 void
-PatchCanvas::auto_menu_position(int& x, int& y, bool& push_in)
+GraphCanvas::auto_menu_position(int& x, int& y, bool& push_in)
 {
 	std::pair<int, int> scroll_offsets;
 	get_scroll_offsets(scroll_offsets.first, scroll_offsets.second);
@@ -556,7 +556,7 @@ PatchCanvas::auto_menu_position(int& x, int& y, bool& push_in)
 }
 
 bool
-PatchCanvas::on_event(GdkEvent* event)
+GraphCanvas::on_event(GdkEvent* event)
 {
 	assert(event);
 
@@ -595,9 +595,9 @@ PatchCanvas::on_event(GdkEvent* event)
 }
 
 void
-PatchCanvas::clear_selection()
+GraphCanvas::clear_selection()
 {
-	PatchWindow* win = _app.window_factory()->patch_window(_patch);
+	GraphWindow* win = _app.window_factory()->graph_window(_graph);
 	if (win) {
 		win->hide_documentation();
 	}
@@ -619,7 +619,7 @@ destroy_node(GanvNode* node, void* data)
 	if (node_module) {
 		app->interface()->del(node_module->block()->uri());
 	} else {
-		PatchPortModule* port_module = dynamic_cast<PatchPortModule*>(module);
+		GraphPortModule* port_module = dynamic_cast<GraphPortModule*>(module);
 		if (port_module) {
 			app->interface()->del(port_module->port()->uri());
 		}
@@ -638,7 +638,7 @@ destroy_edge(GanvEdge* edge, void* data)
 }
 
 void
-PatchCanvas::destroy_selection()
+GraphCanvas::destroy_selection()
 {
 	for_each_selected_node(destroy_node, &_app);
 	for_each_selected_edge(destroy_edge, &_app);
@@ -658,7 +658,7 @@ serialise_node(GanvNode* node, void* data)
 	if (node_module) {
 		serialiser->serialise(node_module->block());
 	} else {
-		PatchPortModule* port_module = dynamic_cast<PatchPortModule*>(module);
+		GraphPortModule* port_module = dynamic_cast<GraphPortModule*>(module);
 		if (port_module) {
 			serialiser->serialise(port_module->port());
 		}
@@ -680,11 +680,11 @@ serialise_edge(GanvEdge* edge, void* data)
 }
 
 void
-PatchCanvas::copy_selection()
+GraphCanvas::copy_selection()
 {
 	static const char* base_uri = "http://drobilla.net/ns/ingen/selection/";
 	Serialisation::Serialiser serialiser(*_app.world());
-	serialiser.start_to_string(_patch->path(), base_uri);
+	serialiser.start_to_string(_graph->path(), base_uri);
 
 	for_each_selected_node(serialise_node, &serialiser);
 	for_each_selected_edge(serialise_edge, &serialiser);
@@ -697,7 +697,7 @@ PatchCanvas::copy_selection()
 }
 
 void
-PatchCanvas::paste()
+GraphCanvas::paste()
 {
 	Glib::ustring str = Gtk::Clipboard::get()->wait_for_text();
 	SharedPtr<Serialisation::Parser> parser = _app.loader()->parser();
@@ -717,13 +717,13 @@ PatchCanvas::paste()
 	clipboard.set_plugins(_app.store()->plugins());
 
 	// mkdir -p
-	string to_create = _patch->path().substr(1);
+	string to_create = _graph->path().substr(1);
 	string created = "/";
 	Resource::Properties props;
 	props.insert(make_pair(uris.rdf_type,
-	                       uris.ingen_Patch));
+	                       uris.ingen_Graph));
 	props.insert(make_pair(uris.ingen_polyphony,
-	                       _app.forge().make(int32_t(_patch->internal_poly()))));
+	                       _app.forge().make(int32_t(_graph->internal_poly()))));
 	clipboard.put(GraphObject::root_uri(), props);
 	size_t first_slash;
 	while (to_create != "/" && !to_create.empty()
@@ -734,14 +734,14 @@ PatchCanvas::paste()
 		to_create = to_create.substr(first_slash + 1);
 	}
 
-	if (!_patch->path().is_root())
-		clipboard.put(_patch->uri(), props);
+	if (!_graph->path().is_root())
+		clipboard.put(_graph->uri(), props);
 
 	boost::optional<Raul::Path>   parent;
 	boost::optional<Raul::Symbol> symbol;
 
-	if (!_patch->path().is_root()) {
-		parent = _patch->path();
+	if (!_graph->path().is_root()) {
+		parent = _graph->path();
 	}
 
 	ClashAvoider avoider(*_app.store().get(), clipboard, &clipboard);
@@ -750,7 +750,7 @@ PatchCanvas::paste()
 	                     parent, symbol);
 
 	for (Store::iterator i = clipboard.begin(); i != clipboard.end(); ++i) {
-		if (_patch->path().is_root() && i->first.is_root())
+		if (_graph->path().is_root() && i->first.is_root())
 			continue;
 
 		GraphObject::Properties& props = i->second->properties();
@@ -769,11 +769,11 @@ PatchCanvas::paste()
 		_pastees.insert(i->first);
 	}
 
-	builder.connect(PtrCast<const PatchModel>(clipboard.object(_patch->path())));
+	builder.connect(PtrCast<const GraphModel>(clipboard.object(_graph->path())));
 }
 
 void
-PatchCanvas::generate_port_name(
+GraphCanvas::generate_port_name(
 	const string& sym_base,  string& symbol,
 	const string& name_base, string& name)
 {
@@ -786,7 +786,7 @@ PatchCanvas::generate_port_name(
 		snprintf(num_buf, sizeof(num_buf), "%u", i);
 		symbol = sym_base + "_";
 		symbol += num_buf;
-		if (!_patch->get_port(Raul::Symbol::symbolify(symbol)))
+		if (!_graph->get_port(Raul::Symbol::symbolify(symbol)))
 			break;
 	}
 
@@ -796,12 +796,12 @@ PatchCanvas::generate_port_name(
 }
 
 void
-PatchCanvas::menu_add_port(const string& sym_base, const string& name_base,
+GraphCanvas::menu_add_port(const string& sym_base, const string& name_base,
                            const Raul::URI& type, bool is_output)
 {
 	string sym, name;
 	generate_port_name(sym_base, sym, name_base, name);
-	const Raul::Path& path = _patch->path().child(Raul::Symbol(sym));
+	const Raul::Path& path = _graph->path().child(Raul::Symbol(sym));
 
 	const URIs& uris = _app.uris();
 
@@ -815,21 +815,21 @@ PatchCanvas::menu_add_port(const string& sym_base, const string& name_base,
 	props.insert(make_pair(uris.rdf_type,
 	                       is_output ? uris.lv2_OutputPort : uris.lv2_InputPort));
 	props.insert(make_pair(uris.lv2_index,
-	                       _app.forge().make(int32_t(_patch->num_ports()))));
+	                       _app.forge().make(int32_t(_graph->num_ports()))));
 	props.insert(make_pair(uris.lv2_name,
 	                       _app.forge().alloc(name.c_str())));
 	_app.interface()->put(GraphObject::path_to_uri(path), props);
 }
 
 void
-PatchCanvas::load_plugin(WeakPtr<PluginModel> weak_plugin)
+GraphCanvas::load_plugin(WeakPtr<PluginModel> weak_plugin)
 {
 	SharedPtr<PluginModel> plugin = weak_plugin.lock();
 	if (!plugin)
 		return;
 
 	Raul::Symbol symbol = plugin->default_block_symbol();
-	unsigned offset = _app.store()->child_name_offset(_patch->path(), symbol);
+	unsigned offset = _app.store()->child_name_offset(_graph->path(), symbol);
 	if (offset != 0) {
 		std::stringstream ss;
 		ss << symbol << "_" << offset;
@@ -837,7 +837,7 @@ PatchCanvas::load_plugin(WeakPtr<PluginModel> weak_plugin)
 	}
 
 	const URIs&      uris = _app.uris();
-	const Raul::Path path = _patch->path().child(symbol);
+	const Raul::Path path = _graph->path().child(symbol);
 
 	// FIXME: polyphony?
 	GraphObject::Properties props = get_initial_data();
@@ -850,7 +850,7 @@ PatchCanvas::load_plugin(WeakPtr<PluginModel> weak_plugin)
 /** Try to guess a suitable location for a new module.
  */
 void
-PatchCanvas::get_new_module_location(double& x, double& y)
+GraphCanvas::get_new_module_location(double& x, double& y)
 {
 	int scroll_x;
 	int scroll_y;
@@ -860,7 +860,7 @@ PatchCanvas::get_new_module_location(double& x, double& y)
 }
 
 GraphObject::Properties
-PatchCanvas::get_initial_data(Resource::Graph ctx)
+GraphCanvas::get_initial_data(Resource::Graph ctx)
 {
 	GraphObject::Properties result;
 	const URIs& uris = _app.uris();
@@ -876,24 +876,24 @@ PatchCanvas::get_initial_data(Resource::Graph ctx)
 }
 
 void
-PatchCanvas::menu_load_plugin()
+GraphCanvas::menu_load_plugin()
 {
 	_app.window_factory()->present_load_plugin(
-		_patch, get_initial_data());
+		_graph, get_initial_data());
 }
 
 void
-PatchCanvas::menu_load_patch()
+GraphCanvas::menu_load_graph()
 {
-	_app.window_factory()->present_load_subpatch(
-		_patch, get_initial_data(Resource::EXTERNAL));
+	_app.window_factory()->present_load_subgraph(
+		_graph, get_initial_data(Resource::EXTERNAL));
 }
 
 void
-PatchCanvas::menu_new_patch()
+GraphCanvas::menu_new_graph()
 {
-	_app.window_factory()->present_new_subpatch(
-		_patch, get_initial_data(Resource::EXTERNAL));
+	_app.window_factory()->present_new_subgraph(
+		_graph, get_initial_data(Resource::EXTERNAL));
 }
 
 } // namespace GUI
diff --git a/src/gui/PatchCanvas.hpp b/src/gui/GraphCanvas.hpp
index 04c30ed3..9144518a 100644
--- a/src/gui/PatchCanvas.hpp
+++ b/src/gui/GraphCanvas.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_GUI_PATCHCANVAS_HPP
-#define INGEN_GUI_PATCHCANVAS_HPP
+#ifndef INGEN_GUI_GRAPHCANVAS_HPP
+#define INGEN_GUI_GRAPHCANVAS_HPP
 
 #include <string>
 #include <map>
@@ -30,31 +30,31 @@
 #include "raul/SharedPtr.hpp"
 #include "raul/Path.hpp"
 
-#include "ingen/client/EdgeModel.hpp"
-#include "ingen/GraphObject.hpp"
 #include "NodeModule.hpp"
+#include "ingen/GraphObject.hpp"
+#include "ingen/client/EdgeModel.hpp"
 
 namespace Ingen {
 
-namespace Client { class PatchModel; }
+namespace Client { class GraphModel; }
 
 namespace GUI {
 
 class NodeModule;
 
-/** Patch canvas widget.
+/** Graph canvas widget.
  *
  * \ingroup GUI
  */
-class PatchCanvas : public Ganv::Canvas
+class GraphCanvas : public Ganv::Canvas
 {
 public:
-	PatchCanvas(App&                                app,
-	            SharedPtr<const Client::PatchModel> patch,
+	GraphCanvas(App&                                app,
+	            SharedPtr<const Client::GraphModel> graph,
 	            int                                 width,
 	            int                                 height);
 
-	virtual ~PatchCanvas() {}
+	virtual ~GraphCanvas() {}
 
 	App& app() { return _app; }
 
@@ -93,8 +93,8 @@ private:
 			const Raul::URI& type, bool is_output);
 
 	void menu_load_plugin();
-	void menu_new_patch();
-	void menu_load_patch();
+	void menu_new_graph();
+	void menu_load_graph();
 	void load_plugin(WeakPtr<Client::PluginModel> plugin);
 
 	void build_menus();
@@ -124,7 +124,7 @@ private:
 	                Ganv::Node* dst);
 
 	App&                                _app;
-	SharedPtr<const Client::PatchModel> _patch;
+	SharedPtr<const Client::GraphModel> _graph;
 
 	typedef std::map<SharedPtr<const Client::ObjectModel>, Ganv::Module*> Views;
 	Views _views;
@@ -160,8 +160,8 @@ private:
 	Gtk::MenuItem*      _menu_add_event_input;
 	Gtk::MenuItem*      _menu_add_event_output;
 	Gtk::MenuItem*      _menu_load_plugin;
-	Gtk::MenuItem*      _menu_load_patch;
-	Gtk::MenuItem*      _menu_new_patch;
+	Gtk::MenuItem*      _menu_load_graph;
+	Gtk::MenuItem*      _menu_new_graph;
 	Gtk::CheckMenuItem* _menu_edit;
 
 	bool _human_names;
@@ -171,4 +171,4 @@ private:
 } // namespace GUI
 } // namespace Ingen
 
-#endif // INGEN_GUI_PATCHCANVAS_HPP
+#endif // INGEN_GUI_GRAPHCANVAS_HPP
diff --git a/src/gui/PatchPortModule.cpp b/src/gui/GraphPortModule.cpp
index ec0e6a04..38735088 100644
--- a/src/gui/PatchPortModule.cpp
+++ b/src/gui/GraphPortModule.cpp
@@ -20,13 +20,13 @@
 
 #include "ingen/Interface.hpp"
 #include "ingen/client/BlockModel.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 
 #include "App.hpp"
 #include "Configuration.hpp"
-#include "PatchCanvas.hpp"
-#include "PatchPortModule.hpp"
-#include "PatchWindow.hpp"
+#include "GraphCanvas.hpp"
+#include "GraphPortModule.hpp"
+#include "GraphWindow.hpp"
 #include "Port.hpp"
 #include "PortMenu.hpp"
 #include "RenameWindow.hpp"
@@ -41,30 +41,30 @@ using namespace Client;
 
 namespace GUI {
 
-PatchPortModule::PatchPortModule(PatchCanvas&                       canvas,
+GraphPortModule::GraphPortModule(GraphCanvas&                       canvas,
                                  SharedPtr<const Client::PortModel> model)
 	: Ganv::Module(canvas, "", 0, 0, false) // FIXME: coords?
 	, _model(model)
 {
 	assert(model);
 
-	assert(PtrCast<const PatchModel>(model->parent()));
+	assert(PtrCast<const GraphModel>(model->parent()));
 
 	set_stacked(model->polyphonic());
 
 	model->signal_property().connect(
-		sigc::mem_fun(this, &PatchPortModule::property_changed));
+		sigc::mem_fun(this, &GraphPortModule::property_changed));
 
 	signal_moved().connect(
-		sigc::mem_fun(this, &PatchPortModule::store_location));
+		sigc::mem_fun(this, &GraphPortModule::store_location));
 }
 
-PatchPortModule*
-PatchPortModule::create(PatchCanvas&               canvas,
+GraphPortModule*
+GraphPortModule::create(GraphCanvas&               canvas,
                         SharedPtr<const PortModel> model,
                         bool                       human)
 {
-	PatchPortModule* ret  = new PatchPortModule(canvas, model);
+	GraphPortModule* ret  = new GraphPortModule(canvas, model);
 	Port*            port = Port::create(canvas.app(), *ret, model, human, true);
 
 	ret->set_port(port);
@@ -77,19 +77,19 @@ PatchPortModule::create(PatchCanvas&               canvas,
 }
 
 App&
-PatchPortModule::app() const
+GraphPortModule::app() const
 {
-	return ((PatchCanvas*)canvas())->app();
+	return ((GraphCanvas*)canvas())->app();
 }
 
 bool
-PatchPortModule::show_menu(GdkEventButton* ev)
+GraphPortModule::show_menu(GdkEventButton* ev)
 {
 	return _port->show_menu(ev);
 }
 
 void
-PatchPortModule::store_location(double ax, double ay)
+GraphPortModule::store_location(double ax, double ay)
 {
 	const URIs& uris = app().uris();
 
@@ -112,7 +112,7 @@ PatchPortModule::store_location(double ax, double ay)
 }
 
 void
-PatchPortModule::show_human_names(bool b)
+GraphPortModule::show_human_names(bool b)
 {
 	const URIs&       uris = app().uris();
 	const Raul::Atom& name = _model->get_property(uris.lv2_name);
@@ -124,13 +124,13 @@ PatchPortModule::show_human_names(bool b)
 }
 
 void
-PatchPortModule::set_name(const std::string& n)
+GraphPortModule::set_name(const std::string& n)
 {
 	_port->set_label(n.c_str());
 }
 
 void
-PatchPortModule::property_changed(const Raul::URI& key, const Raul::Atom& value)
+GraphPortModule::property_changed(const Raul::URI& key, const Raul::Atom& value)
 {
 	const URIs& uris = app().uris();
 	if (value.type() == uris.forge.Float) {
@@ -155,7 +155,7 @@ PatchPortModule::property_changed(const Raul::URI& key, const Raul::Atom& value)
 }
 
 void
-PatchPortModule::set_selected(gboolean b)
+GraphPortModule::set_selected(gboolean b)
 {
 	if (b != get_selected()) {
 		Module::set_selected(b);
diff --git a/src/gui/PatchPortModule.hpp b/src/gui/GraphPortModule.hpp
index b48bbfc4..722f35c3 100644
--- a/src/gui/PatchPortModule.hpp
+++ b/src/gui/GraphPortModule.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_GUI_PATCHPORTMODULE_HPP
-#define INGEN_GUI_PATCHPORTMODULE_HPP
+#ifndef INGEN_GUI_GRAPHPORTMODULE_HPP
+#define INGEN_GUI_GRAPHPORTMODULE_HPP
 
 #include <string>
 
@@ -35,21 +35,21 @@ namespace Ingen { namespace Client {
 namespace Ingen {
 namespace GUI {
 
-class PatchCanvas;
+class GraphCanvas;
 class Port;
 class PortMenu;
 
-/** A "module" to represent a patch's port on its own canvas.
+/** A "module" to represent a graph's port on its own canvas.
  *
  * Translation: This is the nameless single port pseudo module thingy.
  *
  * \ingroup GUI
  */
-class PatchPortModule : public Ganv::Module
+class GraphPortModule : public Ganv::Module
 {
 public:
-	static PatchPortModule* create(
-		PatchCanvas&                       canvas,
+	static GraphPortModule* create(
+		GraphCanvas&                       canvas,
 		SharedPtr<const Client::PortModel> model,
 		bool                               human);
 
@@ -63,7 +63,7 @@ public:
 	SharedPtr<const Client::PortModel> port() const { return _model; }
 
 protected:
-	PatchPortModule(PatchCanvas&                       canvas,
+	GraphPortModule(GraphCanvas&                       canvas,
 	                SharedPtr<const Client::PortModel> model);
 
 	bool show_menu(GdkEventButton* ev);
@@ -80,4 +80,4 @@ protected:
 } // namespace GUI
 } // namespace Ingen
 
-#endif // INGEN_GUI_PATCHPORTMODULE_HPP
+#endif // INGEN_GUI_GRAPHPORTMODULE_HPP
diff --git a/src/gui/GraphTreeWindow.cpp b/src/gui/GraphTreeWindow.cpp
new file mode 100644
index 00000000..7ddbb23a
--- /dev/null
+++ b/src/gui/GraphTreeWindow.cpp
@@ -0,0 +1,234 @@
+/*
+  This file is part of Ingen.
+  Copyright 2007-2012 David Robillard <http://drobilla.net/>
+
+  Ingen is free software: you can redistribute it and/or modify it under the
+  terms of the GNU Affero General Public License as published by the Free
+  Software Foundation, either version 3 of the License, or any later version.
+
+  Ingen is distributed in the hope that it will be useful, but WITHOUT ANY
+  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+  A PARTICULAR PURPOSE.  See the GNU Affero General Public License for details.
+
+  You should have received a copy of the GNU Affero General Public License
+  along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "App.hpp"
+#include "GraphTreeWindow.hpp"
+#include "SubgraphModule.hpp"
+#include "WindowFactory.hpp"
+#include "ingen/Interface.hpp"
+#include "ingen/Log.hpp"
+#include "ingen/client/ClientStore.hpp"
+#include "ingen/client/GraphModel.hpp"
+#include "raul/Path.hpp"
+
+using namespace std;
+
+namespace Ingen {
+
+using namespace Client;
+
+namespace GUI {
+
+GraphTreeWindow::GraphTreeWindow(BaseObjectType*                   cobject,
+                                 const Glib::RefPtr<Gtk::Builder>& xml)
+	: Window(cobject)
+	, _app(NULL)
+	, _enable_signal(true)
+{
+	xml->get_widget_derived("graphs_treeview", _graphs_treeview);
+
+	_graph_treestore = Gtk::TreeStore::create(_graph_tree_columns);
+	_graphs_treeview->set_window(this);
+	_graphs_treeview->set_model(_graph_treestore);
+	Gtk::TreeViewColumn* name_col = Gtk::manage(new Gtk::TreeViewColumn(
+		"Graph", _graph_tree_columns.name_col));
+	Gtk::TreeViewColumn* enabled_col = Gtk::manage(new Gtk::TreeViewColumn(
+		"Run", _graph_tree_columns.enabled_col));
+	name_col->set_resizable(true);
+	name_col->set_expand(true);
+
+	_graphs_treeview->append_column(*name_col);
+	_graphs_treeview->append_column(*enabled_col);
+	Gtk::CellRendererToggle* enabled_renderer = dynamic_cast<Gtk::CellRendererToggle*>(
+		_graphs_treeview->get_column_cell_renderer(1));
+	enabled_renderer->property_activatable() = true;
+
+	_graph_tree_selection = _graphs_treeview->get_selection();
+
+	_graphs_treeview->signal_row_activated().connect(
+		sigc::mem_fun(this, &GraphTreeWindow::event_graph_activated));
+	enabled_renderer->signal_toggled().connect(
+		sigc::mem_fun(this, &GraphTreeWindow::event_graph_enabled_toggled));
+
+	_graphs_treeview->columns_autosize();
+}
+
+void
+GraphTreeWindow::init(App& app, ClientStore& store)
+{
+	_app = &app;
+	store.signal_new_object().connect(
+		sigc::mem_fun(this, &GraphTreeWindow::new_object));
+}
+
+void
+GraphTreeWindow::new_object(SharedPtr<ObjectModel> object)
+{
+	SharedPtr<GraphModel> graph = PtrCast<GraphModel>(object);
+	if (graph)
+		add_graph(graph);
+}
+
+void
+GraphTreeWindow::add_graph(SharedPtr<GraphModel> pm)
+{
+	if (!pm->parent()) {
+		Gtk::TreeModel::iterator iter = _graph_treestore->append();
+		Gtk::TreeModel::Row row = *iter;
+		if (pm->path().is_root()) {
+			row[_graph_tree_columns.name_col] = _app->interface()->uri();
+		} else {
+			row[_graph_tree_columns.name_col] = pm->symbol().c_str();
+		}
+		row[_graph_tree_columns.enabled_col] = pm->enabled();
+		row[_graph_tree_columns.graph_model_col] = pm;
+		_graphs_treeview->expand_row(_graph_treestore->get_path(iter), true);
+	} else {
+		Gtk::TreeModel::Children children = _graph_treestore->children();
+		Gtk::TreeModel::iterator c = find_graph(children, pm->parent());
+
+		if (c != children.end()) {
+			Gtk::TreeModel::iterator iter = _graph_treestore->append(c->children());
+			Gtk::TreeModel::Row row = *iter;
+			row[_graph_tree_columns.name_col] = pm->symbol().c_str();
+			row[_graph_tree_columns.enabled_col] = pm->enabled();
+			row[_graph_tree_columns.graph_model_col] = pm;
+			_graphs_treeview->expand_row(_graph_treestore->get_path(iter), true);
+		}
+	}
+
+	pm->signal_property().connect(
+		sigc::bind(sigc::mem_fun(this, &GraphTreeWindow::graph_property_changed),
+		           pm));
+
+	pm->signal_moved().connect(
+		sigc::bind(sigc::mem_fun(this, &GraphTreeWindow::graph_moved),
+		           pm));
+
+	pm->signal_destroyed().connect(
+		sigc::bind(sigc::mem_fun(this, &GraphTreeWindow::remove_graph),
+		           pm));
+}
+
+void
+GraphTreeWindow::remove_graph(SharedPtr<GraphModel> pm)
+{
+	Gtk::TreeModel::iterator i = find_graph(_graph_treestore->children(), pm);
+	if (i != _graph_treestore->children().end())
+		_graph_treestore->erase(i);
+}
+
+Gtk::TreeModel::iterator
+GraphTreeWindow::find_graph(
+		Gtk::TreeModel::Children       root,
+		SharedPtr<Client::ObjectModel> graph)
+{
+	for (Gtk::TreeModel::iterator c = root.begin(); c != root.end(); ++c) {
+		SharedPtr<GraphModel> pm = (*c)[_graph_tree_columns.graph_model_col];
+		if (graph == pm) {
+			return c;
+		} else if ((*c)->children().size() > 0) {
+			Gtk::TreeModel::iterator ret = find_graph(c->children(), graph);
+			if (ret != c->children().end())
+				return ret;
+		}
+	}
+	return root.end();
+}
+
+/** Show the context menu for the selected graph in the graphs treeview.
+ */
+void
+GraphTreeWindow::show_graph_menu(GdkEventButton* ev)
+{
+	Gtk::TreeModel::iterator active = _graph_tree_selection->get_selected();
+	if (active) {
+		Gtk::TreeModel::Row row = *active;
+		SharedPtr<GraphModel> pm = row[_graph_tree_columns.graph_model_col];
+		if (pm) {
+			_app->log().warn("TODO: graph menu from tree window");
+		}
+	}
+}
+
+void
+GraphTreeWindow::event_graph_activated(const Gtk::TreeModel::Path& path, Gtk::TreeView::Column* col)
+{
+	Gtk::TreeModel::iterator active = _graph_treestore->get_iter(path);
+	Gtk::TreeModel::Row row = *active;
+	SharedPtr<GraphModel> pm = row[_graph_tree_columns.graph_model_col];
+
+	_app->window_factory()->present_graph(pm);
+}
+
+void
+GraphTreeWindow::event_graph_enabled_toggled(const Glib::ustring& path_str)
+{
+	Gtk::TreeModel::Path path(path_str);
+	Gtk::TreeModel::iterator active = _graph_treestore->get_iter(path);
+	Gtk::TreeModel::Row row = *active;
+
+	SharedPtr<GraphModel> pm = row[_graph_tree_columns.graph_model_col];
+	assert(pm);
+
+	if (_enable_signal)
+		_app->interface()->set_property(
+			pm->uri(),
+			_app->uris().ingen_enabled,
+			_app->forge().make((bool)!pm->enabled()));
+}
+
+void
+GraphTreeWindow::graph_property_changed(const Raul::URI&      key,
+                                        const Raul::Atom&     value,
+                                        SharedPtr<GraphModel> graph)
+{
+	const URIs& uris = _app->uris();
+	_enable_signal = false;
+	if (key == uris.ingen_enabled && value.type() == uris.forge.Bool) {
+		Gtk::TreeModel::iterator i = find_graph(_graph_treestore->children(), graph);
+		if (i != _graph_treestore->children().end()) {
+			Gtk::TreeModel::Row row = *i;
+			row[_graph_tree_columns.enabled_col] = value.get_bool();
+		} else {
+			_app->log().error(Raul::fmt("Unable to find graph %1%\n")
+			                  % graph->path());
+		}
+	}
+	_enable_signal = true;
+}
+
+void
+GraphTreeWindow::graph_moved(SharedPtr<GraphModel> graph)
+{
+	_enable_signal = false;
+
+	Gtk::TreeModel::iterator i
+		= find_graph(_graph_treestore->children(), graph);
+
+	if (i != _graph_treestore->children().end()) {
+		Gtk::TreeModel::Row row = *i;
+		row[_graph_tree_columns.name_col] = graph->symbol().c_str();
+	} else {
+		_app->log().error(Raul::fmt("Unable to find graph %1%\n")
+		                  % graph->path());
+	}
+
+	_enable_signal = true;
+}
+
+} // namespace GUI
+} // namespace Ingen
diff --git a/src/gui/PatchTreeWindow.hpp b/src/gui/GraphTreeWindow.hpp
index 86e10370..3bd50b76 100644
--- a/src/gui/PatchTreeWindow.hpp
+++ b/src/gui/GraphTreeWindow.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_GUI_PATCHTREEWINDOW_HPP
-#define INGEN_GUI_PATCHTREEWINDOW_HPP
+#ifndef INGEN_GUI_GRAPHTREEWINDOW_HPP
+#define INGEN_GUI_GRAPHTREEWINDOW_HPP
 
 #include <gtkmm/builder.h>
 #include <gtkmm/treemodel.h>
@@ -32,89 +32,92 @@ namespace Client { class ClientStore; class ObjectModel; }
 
 namespace GUI {
 
-class PatchWindow;
-class PatchTreeView;
+class GraphWindow;
+class GraphTreeView;
 
-/** Window with a TreeView of all loaded patches.
+/** Window with a TreeView of all loaded graphs.
  *
  * \ingroup GUI
  */
-class PatchTreeWindow : public Window
+class GraphTreeWindow : public Window
 {
 public:
-	PatchTreeWindow(BaseObjectType*                   cobject,
+	GraphTreeWindow(BaseObjectType*                   cobject,
 	                const Glib::RefPtr<Gtk::Builder>& xml);
 
 	void init(App& app, Client::ClientStore& store);
 
 	void new_object(SharedPtr<Client::ObjectModel> object);
 
-	void patch_property_changed(const Raul::URI& key, const Raul::Atom& value,
-			SharedPtr<Client::PatchModel> pm);
+	void graph_property_changed(const Raul::URI&              key,
+	                            const Raul::Atom&             value,
+	                            SharedPtr<Client::GraphModel> gm);
 
-	void patch_moved(SharedPtr<Client::PatchModel> patch);
+	void graph_moved(SharedPtr<Client::GraphModel> graph);
 
-	void add_patch(SharedPtr<Client::PatchModel> pm);
-	void remove_patch(SharedPtr<Client::PatchModel> pm);
-	void show_patch_menu(GdkEventButton* ev);
+	void add_graph(SharedPtr<Client::GraphModel> gm);
+	void remove_graph(SharedPtr<Client::GraphModel> gm);
+	void show_graph_menu(GdkEventButton* ev);
 
 protected:
-	void event_patch_activated(const Gtk::TreeModel::Path& path, Gtk::TreeView::Column* col);
-	void event_patch_enabled_toggled(const Glib::ustring& path_str);
+	void event_graph_activated(const Gtk::TreeModel::Path& path,
+	                           Gtk::TreeView::Column*      col);
 
-	Gtk::TreeModel::iterator find_patch(
+	void event_graph_enabled_toggled(const Glib::ustring& path_str);
+
+	Gtk::TreeModel::iterator find_graph(
 			Gtk::TreeModel::Children       root,
-			SharedPtr<Client::ObjectModel> patch);
+			SharedPtr<Client::ObjectModel> graph);
 
-	PatchTreeView* _patches_treeview;
+	GraphTreeView* _graphs_treeview;
 
-	struct PatchTreeModelColumns : public Gtk::TreeModel::ColumnRecord
+	struct GraphTreeModelColumns : public Gtk::TreeModel::ColumnRecord
 	{
-		PatchTreeModelColumns() {
+		GraphTreeModelColumns() {
 			add(name_col);
 			add(enabled_col);
-			add(patch_model_col);
+			add(graph_model_col);
 		}
 
 		Gtk::TreeModelColumn<Glib::ustring>                  name_col;
 		Gtk::TreeModelColumn<bool>                           enabled_col;
-		Gtk::TreeModelColumn<SharedPtr<Client::PatchModel> > patch_model_col;
+		Gtk::TreeModelColumn<SharedPtr<Client::GraphModel> > graph_model_col;
 	};
 
 	App*                             _app;
-	PatchTreeModelColumns            _patch_tree_columns;
-	Glib::RefPtr<Gtk::TreeStore>     _patch_treestore;
-	Glib::RefPtr<Gtk::TreeSelection> _patch_tree_selection;
+	GraphTreeModelColumns            _graph_tree_columns;
+	Glib::RefPtr<Gtk::TreeStore>     _graph_treestore;
+	Glib::RefPtr<Gtk::TreeSelection> _graph_tree_selection;
 	bool                             _enable_signal;
 };
 
-/** Derived TreeView class to support context menus for patches */
-class PatchTreeView : public Gtk::TreeView
+/** Derived TreeView class to support context menus for graphs */
+class GraphTreeView : public Gtk::TreeView
 {
 public:
-	PatchTreeView(BaseObjectType*                   cobject,
+	GraphTreeView(BaseObjectType*                   cobject,
 	              const Glib::RefPtr<Gtk::Builder>& xml)
 		: Gtk::TreeView(cobject)
 		, _window(NULL)
 	{}
 
-	void set_window(PatchTreeWindow* win) { _window = win; }
+	void set_window(GraphTreeWindow* win) { _window = win; }
 
 	bool on_button_press_event(GdkEventButton* ev) {
 		bool ret = Gtk::TreeView::on_button_press_event(ev);
 
 		if ((ev->type == GDK_BUTTON_PRESS) && (ev->button == 3))
-			_window->show_patch_menu(ev);
+			_window->show_graph_menu(ev);
 
 		return ret;
 	}
 
 private:
-	PatchTreeWindow* _window;
+	GraphTreeWindow* _window;
 
-}; // struct PatchTreeView
+}; // struct GraphTreeView
 
 } // namespace GUI
 } // namespace Ingen
 
-#endif // INGEN_GUI_PATCHTREEWINDOW_HPP
+#endif // INGEN_GUI_GRAPHTREEWINDOW_HPP
diff --git a/src/gui/PatchView.cpp b/src/gui/GraphView.cpp
index efb37d11..119438e6 100644
--- a/src/gui/PatchView.cpp
+++ b/src/gui/GraphView.cpp
@@ -18,14 +18,14 @@
 #include <fstream>
 
 #include "ingen/Interface.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 
 #include "App.hpp"
 #include "LoadPluginWindow.hpp"
-#include "NewSubpatchWindow.hpp"
-#include "PatchCanvas.hpp"
-#include "PatchTreeWindow.hpp"
-#include "PatchView.hpp"
+#include "NewSubgraphWindow.hpp"
+#include "GraphCanvas.hpp"
+#include "GraphTreeWindow.hpp"
+#include "GraphView.hpp"
 #include "WidgetFactory.hpp"
 
 using namespace std;
@@ -36,7 +36,7 @@ using namespace Client;
 
 namespace GUI {
 
-PatchView::PatchView(BaseObjectType*                   cobject,
+GraphView::GraphView(BaseObjectType*                   cobject,
                      const Glib::RefPtr<Gtk::Builder>& xml)
 	: Gtk::Box(cobject)
 	, _app(NULL)
@@ -45,15 +45,15 @@ PatchView::PatchView(BaseObjectType*                   cobject,
 {
 	property_visible() = false;
 
-	xml->get_widget("patch_view_breadcrumb_container", _breadcrumb_container);
-	xml->get_widget("patch_view_toolbar", _toolbar);
-	xml->get_widget("patch_view_process_but", _process_but);
-	xml->get_widget("patch_view_poly_spin", _poly_spin);
-	xml->get_widget("patch_view_refresh_but", _refresh_but);
-	xml->get_widget("patch_view_save_but", _save_but);
-	xml->get_widget("patch_view_zoom_full_but", _zoom_full_but);
-	xml->get_widget("patch_view_zoom_normal_but", _zoom_normal_but);
-	xml->get_widget("patch_view_scrolledwindow", _canvas_scrolledwindow);
+	xml->get_widget("graph_view_breadcrumb_container", _breadcrumb_container);
+	xml->get_widget("graph_view_toolbar", _toolbar);
+	xml->get_widget("graph_view_process_but", _process_but);
+	xml->get_widget("graph_view_poly_spin", _poly_spin);
+	xml->get_widget("graph_view_refresh_but", _refresh_but);
+	xml->get_widget("graph_view_save_but", _save_but);
+	xml->get_widget("graph_view_zoom_full_but", _zoom_full_but);
+	xml->get_widget("graph_view_zoom_normal_but", _zoom_normal_but);
+	xml->get_widget("graph_view_scrolledwindow", _canvas_scrolledwindow);
 
 	_toolbar->set_toolbar_style(Gtk::TOOLBAR_ICONS);
 	_canvas_scrolledwindow->property_hadjustment().get_value()->set_step_increment(10);
@@ -61,76 +61,76 @@ PatchView::PatchView(BaseObjectType*                   cobject,
 }
 
 void
-PatchView::init(App& app)
+GraphView::init(App& app)
 {
 	_app = &app;
 }
 
 void
-PatchView::set_patch(SharedPtr<const PatchModel> patch)
+GraphView::set_graph(SharedPtr<const GraphModel> graph)
 {
 	assert(!_canvas); // FIXME: remove
 
 	assert(_breadcrumb_container); // ensure created
 
-	_patch = patch;
-	_canvas = SharedPtr<PatchCanvas>(new PatchCanvas(*_app, patch, 1600*2, 1200*2));
+	_graph = graph;
+	_canvas = SharedPtr<GraphCanvas>(new GraphCanvas(*_app, graph, 1600*2, 1200*2));
 	_canvas->build();
 
 	_canvas_scrolledwindow->add(_canvas->widget());
 
 	_poly_spin->set_range(1, 128);
 	_poly_spin->set_increments(1, 4);
-	_poly_spin->set_value(patch->internal_poly());
+	_poly_spin->set_value(graph->internal_poly());
 
-	for (GraphObject::Properties::const_iterator i = patch->properties().begin();
-			i != patch->properties().end(); ++i)
+	for (GraphObject::Properties::const_iterator i = graph->properties().begin();
+			i != graph->properties().end(); ++i)
 		property_changed(i->first, i->second);
 
 	// Connect model signals to track state
-	patch->signal_property().connect(
-		sigc::mem_fun(this, &PatchView::property_changed));
+	graph->signal_property().connect(
+		sigc::mem_fun(this, &GraphView::property_changed));
 
 	// Connect widget signals to do things
 	_process_but->signal_toggled().connect(
-		sigc::mem_fun(this, &PatchView::process_toggled));
+		sigc::mem_fun(this, &GraphView::process_toggled));
 	_refresh_but->signal_clicked().connect(
-		sigc::mem_fun(this, &PatchView::refresh_clicked));
+		sigc::mem_fun(this, &GraphView::refresh_clicked));
 
 	_zoom_normal_but->signal_clicked().connect(sigc::bind(sigc::mem_fun(
-		_canvas.get(), &PatchCanvas::set_zoom), 1.0));
+		_canvas.get(), &GraphCanvas::set_zoom), 1.0));
 
 	_zoom_full_but->signal_clicked().connect(
-		sigc::mem_fun(_canvas.get(), &PatchCanvas::zoom_full));
+		sigc::mem_fun(_canvas.get(), &GraphCanvas::zoom_full));
 
 	_poly_spin->signal_value_changed().connect(
-			sigc::mem_fun(*this, &PatchView::poly_changed));
+			sigc::mem_fun(*this, &GraphView::poly_changed));
 
 	#if 0
 	_canvas->signal_item_entered.connect(
-			sigc::mem_fun(*this, &PatchView::canvas_item_entered));
+			sigc::mem_fun(*this, &GraphView::canvas_item_entered));
 
 	_canvas->signal_item_left.connect(
-			sigc::mem_fun(*this, &PatchView::canvas_item_left));
+			sigc::mem_fun(*this, &GraphView::canvas_item_left));
 	#endif
 
 	_canvas->widget().grab_focus();
 }
 
-SharedPtr<PatchView>
-PatchView::create(App& app, SharedPtr<const PatchModel> patch)
+SharedPtr<GraphView>
+GraphView::create(App& app, SharedPtr<const GraphModel> graph)
 {
-	PatchView* result = NULL;
+	GraphView* result = NULL;
 	Glib::RefPtr<Gtk::Builder> xml = WidgetFactory::create("warehouse_win");
-	xml->get_widget_derived("patch_view_box", result);
+	xml->get_widget_derived("graph_view_box", result);
 	result->init(app);
-	result->set_patch(patch);
-	return SharedPtr<PatchView>(result);
+	result->set_graph(graph);
+	return SharedPtr<GraphView>(result);
 }
 
 #if 0
 void
-PatchView::canvas_item_entered(Gnome::Canvas::Item* item)
+GraphView::canvas_item_entered(Gnome::Canvas::Item* item)
 {
 	NodeModule* m = dynamic_cast<NodeModule*>(item);
 	if (m)
@@ -142,7 +142,7 @@ PatchView::canvas_item_entered(Gnome::Canvas::Item* item)
 }
 
 void
-PatchView::canvas_item_left(Gnome::Canvas::Item* item)
+GraphView::canvas_item_left(Gnome::Canvas::Item* item)
 {
 	NodeModule* m = dynamic_cast<NodeModule*>(item);
 	if (m) {
@@ -157,37 +157,37 @@ PatchView::canvas_item_left(Gnome::Canvas::Item* item)
 #endif
 
 void
-PatchView::process_toggled()
+GraphView::process_toggled()
 {
 	if (!_enable_signal)
 		return;
 
 	_app->interface()->set_property(
-		_patch->uri(),
+		_graph->uri(),
 		_app->uris().ingen_enabled,
 		_app->forge().make((bool)_process_but->get_active()));
 }
 
 void
-PatchView::poly_changed()
+GraphView::poly_changed()
 {
 	const int poly = _poly_spin->get_value_as_int();
-	if (_enable_signal && poly != (int)_patch->internal_poly()) {
+	if (_enable_signal && poly != (int)_graph->internal_poly()) {
 		_app->interface()->set_property(
-			_patch->uri(),
+			_graph->uri(),
 			_app->uris().ingen_polyphony,
 			_app->forge().make(poly));
 	}
 }
 
 void
-PatchView::refresh_clicked()
+GraphView::refresh_clicked()
 {
-	_app->interface()->get(_patch->uri());
+	_app->interface()->get(_graph->uri());
 }
 
 void
-PatchView::property_changed(const Raul::URI& predicate, const Raul::Atom& value)
+GraphView::property_changed(const Raul::URI& predicate, const Raul::Atom& value)
 {
 	_enable_signal = false;
 	if (predicate == _app->uris().ingen_enabled) {
diff --git a/src/gui/PatchView.hpp b/src/gui/GraphView.hpp
index 14183a89..cae073af 100644
--- a/src/gui/PatchView.hpp
+++ b/src/gui/GraphView.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_GUI_PATCHVIEW_HPP
-#define INGEN_GUI_PATCHVIEW_HPP
+#ifndef INGEN_GUI_GRAPHVIEW_HPP
+#define INGEN_GUI_GRAPHVIEW_HPP
 
 #include <gtkmm/box.h>
 #include <gtkmm/builder.h>
@@ -36,7 +36,7 @@ namespace Ingen {
 namespace Client {
 	class PortModel;
 	class MetadataModel;
-	class PatchModel;
+	class GraphModel;
 	class ObjectModel;
 }
 
@@ -44,35 +44,35 @@ namespace GUI {
 
 class App;
 class LoadPluginWindow;
-class NewSubpatchWindow;
-class PatchCanvas;
-class PatchDescriptionWindow;
-class SubpatchModule;
+class NewSubgraphWindow;
+class GraphCanvas;
+class GraphDescriptionWindow;
+class SubgraphModule;
 
-/** The patch specific contents of a PatchWindow (ie the canvas and whatever else).
+/** The graph specific contents of a GraphWindow (ie the canvas and whatever else).
  *
  * \ingroup GUI
  */
-class PatchView : public Gtk::Box
+class GraphView : public Gtk::Box
 {
 public:
-	PatchView(BaseObjectType*                   cobject,
+	GraphView(BaseObjectType*                   cobject,
 	          const Glib::RefPtr<Gtk::Builder>& xml);
 
 	void init(App& app);
 
-	SharedPtr<PatchCanvas>              canvas()               const { return _canvas; }
-	SharedPtr<const Client::PatchModel> patch()                const { return _patch; }
+	SharedPtr<GraphCanvas>              canvas()               const { return _canvas; }
+	SharedPtr<const Client::GraphModel> graph()                const { return _graph; }
 	Gtk::ToolItem*                      breadcrumb_container() const { return _breadcrumb_container; }
 
-	static SharedPtr<PatchView> create(App& app,
-	                                   SharedPtr<const Client::PatchModel> patch);
+	static SharedPtr<GraphView> create(App& app,
+	                                   SharedPtr<const Client::GraphModel> graph);
 
 	sigc::signal<void, const Client::ObjectModel*> signal_object_entered;
 	sigc::signal<void, const Client::ObjectModel*> signal_object_left;
 
 private:
-	void set_patch(SharedPtr<const Client::PatchModel> patch);
+	void set_graph(SharedPtr<const Client::GraphModel> graph);
 
 	void process_toggled();
 	void poly_changed();
@@ -90,8 +90,8 @@ private:
 
 	App* _app;
 
-	SharedPtr<const Client::PatchModel> _patch;
-	SharedPtr<PatchCanvas>              _canvas;
+	SharedPtr<const Client::GraphModel> _graph;
+	SharedPtr<GraphCanvas>              _canvas;
 
 	Gtk::ScrolledWindow*   _canvas_scrolledwindow;
 	Gtk::Toolbar*          _toolbar;
@@ -109,4 +109,4 @@ private:
 } // namespace GUI
 } // namespace Ingen
 
-#endif // INGEN_GUI_PATCHVIEW_HPP
+#endif // INGEN_GUI_GRAPHVIEW_HPP
diff --git a/src/gui/PatchWindow.cpp b/src/gui/GraphWindow.cpp
index 9b3d1a97..0767f76d 100644
--- a/src/gui/PatchWindow.cpp
+++ b/src/gui/GraphWindow.cpp
@@ -15,18 +15,18 @@
 */
 
 #include "ingen/client/ClientStore.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 
 #include "App.hpp"
-#include "PatchCanvas.hpp"
-#include "PatchView.hpp"
-#include "PatchWindow.hpp"
+#include "GraphCanvas.hpp"
+#include "GraphView.hpp"
+#include "GraphWindow.hpp"
 #include "WindowFactory.hpp"
 
 namespace Ingen {
 namespace GUI {
 
-PatchWindow::PatchWindow(BaseObjectType*                   cobject,
+GraphWindow::GraphWindow(BaseObjectType*                   cobject,
                          const Glib::RefPtr<Gtk::Builder>& xml)
 	: Window(cobject)
 	, _box(NULL)
@@ -36,18 +36,18 @@ PatchWindow::PatchWindow(BaseObjectType*                   cobject,
 {
 	property_visible() = false;
 
-	xml->get_widget_derived("patch_win_vbox", _box);
+	xml->get_widget_derived("graph_win_vbox", _box);
 
 	set_title("Ingen");
 }
 
-PatchWindow::~PatchWindow()
+GraphWindow::~GraphWindow()
 {
 	delete _box;
 }
 
 void
-PatchWindow::init_window(App& app)
+GraphWindow::init_window(App& app)
 {
 	Window::init_window(app);
 	_box->init_box(app);
@@ -55,7 +55,7 @@ PatchWindow::init_window(App& app)
 }
 
 void
-PatchWindow::on_show()
+GraphWindow::on_show()
 {
 	if (_position_stored)
 		move(_x, _y);
@@ -66,7 +66,7 @@ PatchWindow::on_show()
 }
 
 void
-PatchWindow::on_hide()
+GraphWindow::on_hide()
 {
 	_position_stored = true;
 	get_position(_x, _y);
diff --git a/src/gui/PatchWindow.hpp b/src/gui/GraphWindow.hpp
index b3213327..794619b8 100644
--- a/src/gui/PatchWindow.hpp
+++ b/src/gui/GraphWindow.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_GUI_PATCH_WINDOW_HPP
-#define INGEN_GUI_PATCH_WINDOW_HPP
+#ifndef INGEN_GUI_GRAPH_WINDOW_HPP
+#define INGEN_GUI_GRAPH_WINDOW_HPP
 
 #include <string>
 
@@ -23,33 +23,33 @@
 
 #include "raul/SharedPtr.hpp"
 
-#include "PatchBox.hpp"
+#include "GraphBox.hpp"
 #include "Window.hpp"
 
 namespace Ingen {
 
 namespace Client {
-	class PatchModel;
+	class GraphModel;
 }
 
 namespace GUI {
 
-/** A window for a patch.
+/** A window for a graph.
  *
  * \ingroup GUI
  */
-class PatchWindow : public Window
+class GraphWindow : public Window
 {
 public:
-	PatchWindow(BaseObjectType*                   cobject,
+	GraphWindow(BaseObjectType*                   cobject,
 	            const Glib::RefPtr<Gtk::Builder>& xml);
 
-	~PatchWindow();
+	~GraphWindow();
 
 	void init_window(App& app);
 
-	SharedPtr<const Client::PatchModel> patch() const { return _box->patch(); }
-	PatchBox*                           box()   const { return _box; }
+	SharedPtr<const Client::GraphModel> graph() const { return _box->graph(); }
+	GraphBox*                           box()   const { return _box; }
 
 	void show_documentation(const std::string& doc, bool html) {
 		_box->show_documentation(doc, html);
@@ -69,7 +69,7 @@ protected:
 	void on_show();
 
 private:
-	PatchBox* _box;
+	GraphBox* _box;
 	bool      _position_stored;
 	int       _x;
 	int       _y;
@@ -78,4 +78,4 @@ private:
 } // namespace GUI
 } // namespace Ingen
 
-#endif // INGEN_GUI_PATCH_WINDOW_HPP
+#endif // INGEN_GUI_GRAPH_WINDOW_HPP
diff --git a/src/gui/LoadPatchWindow.cpp b/src/gui/LoadGraphWindow.cpp
index 7ba348a6..9f4dde5c 100644
--- a/src/gui/LoadPatchWindow.cpp
+++ b/src/gui/LoadGraphWindow.cpp
@@ -24,13 +24,13 @@
 #include "ingen/Interface.hpp"
 #include "ingen/client/BlockModel.hpp"
 #include "ingen/client/ClientStore.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 #include "ingen/runtime_paths.hpp"
 
 #include "App.hpp"
 #include "Configuration.hpp"
-#include "LoadPatchWindow.hpp"
-#include "PatchView.hpp"
+#include "LoadGraphWindow.hpp"
+#include "GraphView.hpp"
 #include "ThreadedLoader.hpp"
 
 using namespace std;
@@ -41,31 +41,31 @@ using namespace Client;
 
 namespace GUI {
 
-LoadPatchWindow::LoadPatchWindow(BaseObjectType*                   cobject,
+LoadGraphWindow::LoadGraphWindow(BaseObjectType*                   cobject,
                                  const Glib::RefPtr<Gtk::Builder>& xml)
 	: Gtk::FileChooserDialog(cobject)
 	, _app(NULL)
 	, _merge_ports(false)
 {
-	xml->get_widget("load_patch_symbol_label", _symbol_label);
-	xml->get_widget("load_patch_symbol_entry", _symbol_entry);
-	xml->get_widget("load_patch_ports_label", _ports_label);
-	xml->get_widget("load_patch_merge_ports_radio", _merge_ports_radio);
-	xml->get_widget("load_patch_insert_ports_radio", _insert_ports_radio);
-	xml->get_widget("load_patch_poly_voices_radio", _poly_voices_radio);
-	xml->get_widget("load_patch_poly_from_file_radio", _poly_from_file_radio);
-	xml->get_widget("load_patch_poly_spinbutton", _poly_spinbutton);
-	xml->get_widget("load_patch_ok_button", _ok_button);
-	xml->get_widget("load_patch_cancel_button", _cancel_button);
+	xml->get_widget("load_graph_symbol_label", _symbol_label);
+	xml->get_widget("load_graph_symbol_entry", _symbol_entry);
+	xml->get_widget("load_graph_ports_label", _ports_label);
+	xml->get_widget("load_graph_merge_ports_radio", _merge_ports_radio);
+	xml->get_widget("load_graph_insert_ports_radio", _insert_ports_radio);
+	xml->get_widget("load_graph_poly_voices_radio", _poly_voices_radio);
+	xml->get_widget("load_graph_poly_from_file_radio", _poly_from_file_radio);
+	xml->get_widget("load_graph_poly_spinbutton", _poly_spinbutton);
+	xml->get_widget("load_graph_ok_button", _ok_button);
+	xml->get_widget("load_graph_cancel_button", _cancel_button);
 
 	_cancel_button->signal_clicked().connect(
-			sigc::mem_fun(this, &LoadPatchWindow::cancel_clicked));
+			sigc::mem_fun(this, &LoadGraphWindow::cancel_clicked));
 	_ok_button->signal_clicked().connect(
-			sigc::mem_fun(this, &LoadPatchWindow::ok_clicked));
+			sigc::mem_fun(this, &LoadGraphWindow::ok_clicked));
 	_merge_ports_radio->signal_toggled().connect(
-			sigc::mem_fun(this, &LoadPatchWindow::merge_ports_selected));
+			sigc::mem_fun(this, &LoadGraphWindow::merge_ports_selected));
 	_insert_ports_radio->signal_toggled().connect(
-			sigc::mem_fun(this, &LoadPatchWindow::insert_ports_selected));
+			sigc::mem_fun(this, &LoadGraphWindow::insert_ports_selected));
 	_poly_from_file_radio->signal_toggled().connect(sigc::bind(
 			sigc::mem_fun(_poly_spinbutton, &Gtk::SpinButton::set_sensitive),
 			false));
@@ -74,11 +74,11 @@ LoadPatchWindow::LoadPatchWindow(BaseObjectType*                   cobject,
 			true));
 
 	signal_selection_changed().connect(
-			sigc::mem_fun(this, &LoadPatchWindow::selection_changed));
+			sigc::mem_fun(this, &LoadGraphWindow::selection_changed));
 
 	Gtk::FileFilter filt;
 	filt.add_pattern("*.ttl");
-	filt.set_name("Ingen patch files (*.ttl)");
+	filt.set_name("Ingen graph files (*.ttl)");
 	filt.add_pattern("*.ingen");
 	filt.set_name("Ingen bundles (*.ingen)");
 
@@ -87,19 +87,19 @@ LoadPatchWindow::LoadPatchWindow(BaseObjectType*                   cobject,
 	property_select_multiple() = true;
 
 	// Add global examples directory to "shortcut folders" (bookmarks)
-	const string examples_dir = Ingen::data_file_path("patches");
+	const string examples_dir = Ingen::data_file_path("graphs");
 	if (Glib::file_test(examples_dir, Glib::FILE_TEST_IS_DIR)) {
 		add_shortcut_folder(examples_dir);
 	}
 }
 
 void
-LoadPatchWindow::present(SharedPtr<const PatchModel> patch,
+LoadGraphWindow::present(SharedPtr<const GraphModel> graph,
                          bool                        import,
                          GraphObject::Properties     data)
 {
 	_import = import;
-	set_patch(patch);
+	set_graph(graph);
 	_symbol_label->property_visible() = !import;
 	_symbol_entry->property_visible() = !import;
 	_ports_label->property_visible() = _import;
@@ -109,43 +109,43 @@ LoadPatchWindow::present(SharedPtr<const PatchModel> patch,
 	Gtk::Window::present();
 }
 
-/** Sets the patch model for this window and initializes everything.
+/** Sets the graph model for this window and initializes everything.
  *
  * This function MUST be called before using the window in any way!
  */
 void
-LoadPatchWindow::set_patch(SharedPtr<const PatchModel> patch)
+LoadGraphWindow::set_graph(SharedPtr<const GraphModel> graph)
 {
-	_patch = patch;
+	_graph = graph;
 	_symbol_entry->set_text("");
 	_symbol_entry->set_sensitive(!_import);
-	_poly_spinbutton->set_value(patch->internal_poly());
+	_poly_spinbutton->set_value(graph->internal_poly());
 }
 
 void
-LoadPatchWindow::on_show()
+LoadGraphWindow::on_show()
 {
-	if (_app->configuration()->patch_folder().length() > 0)
-		set_current_folder(_app->configuration()->patch_folder());
+	if (_app->configuration()->graph_folder().length() > 0)
+		set_current_folder(_app->configuration()->graph_folder());
 	Gtk::FileChooserDialog::on_show();
 }
 
 void
-LoadPatchWindow::merge_ports_selected()
+LoadGraphWindow::merge_ports_selected()
 {
 	_merge_ports = true;
 }
 
 void
-LoadPatchWindow::insert_ports_selected()
+LoadGraphWindow::insert_ports_selected()
 {
 	_merge_ports = false;
 }
 
 void
-LoadPatchWindow::ok_clicked()
+LoadGraphWindow::ok_clicked()
 {
-	if (!_patch) {
+	if (!_graph) {
 		hide();
 		return;
 	}
@@ -161,15 +161,15 @@ LoadPatchWindow::ok_clicked()
 		return;
 
 	if (_import) {
-		// If unset load_patch will load value
+		// If unset load_graph will load value
 		boost::optional<Raul::Path>   parent;
 		boost::optional<Raul::Symbol> symbol;
-		if (!_patch->path().is_root()) {
-			parent = _patch->path().parent();
-			symbol = _patch->symbol();
+		if (!_graph->path().is_root()) {
+			parent = _graph->path().parent();
+			symbol = _graph->symbol();
 		}
 
-		_app->loader()->load_patch(true, get_filename(),
+		_app->loader()->load_graph(true, get_filename(),
 				parent, symbol, _initial_data);
 
 	} else {
@@ -187,24 +187,24 @@ LoadPatchWindow::ok_clicked()
 
 			symbol = avoid_symbol_clash(symbol);
 
-			_app->loader()->load_patch(false, *i,
-					_patch->path(), symbol, _initial_data);
+			_app->loader()->load_graph(false, *i,
+					_graph->path(), symbol, _initial_data);
 		}
 	}
 
-	_patch.reset();
+	_graph.reset();
 	hide();
 }
 
 void
-LoadPatchWindow::cancel_clicked()
+LoadGraphWindow::cancel_clicked()
 {
-	_patch.reset();
+	_graph.reset();
 	hide();
 }
 
 Raul::Symbol
-LoadPatchWindow::symbol_from_filename(const Glib::ustring& filename)
+LoadGraphWindow::symbol_from_filename(const Glib::ustring& filename)
 {
 	std::string symbol_str = Glib::path_get_basename(get_filename());
 	symbol_str = symbol_str.substr(0, symbol_str.find('.'));
@@ -212,10 +212,10 @@ LoadPatchWindow::symbol_from_filename(const Glib::ustring& filename)
 }
 
 Raul::Symbol
-LoadPatchWindow::avoid_symbol_clash(const Raul::Symbol& symbol)
+LoadGraphWindow::avoid_symbol_clash(const Raul::Symbol& symbol)
 {
 	unsigned offset = _app->store()->child_name_offset(
-			_patch->path(), symbol);
+			_graph->path(), symbol);
 
 	if (offset != 0) {
 		std::stringstream ss;
@@ -227,7 +227,7 @@ LoadPatchWindow::avoid_symbol_clash(const Raul::Symbol& symbol)
 }
 
 void
-LoadPatchWindow::selection_changed()
+LoadGraphWindow::selection_changed()
 {
 	if (_import)
 		return;
diff --git a/src/gui/LoadPatchWindow.hpp b/src/gui/LoadGraphWindow.hpp
index a919a648..2af8e9d2 100644
--- a/src/gui/LoadPatchWindow.hpp
+++ b/src/gui/LoadGraphWindow.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_GUI_LOADSUBPATCHWINDOW_HPP
-#define INGEN_GUI_LOADSUBPATCHWINDOW_HPP
+#ifndef INGEN_GUI_LOADGRAPHWINDOW_HPP
+#define INGEN_GUI_LOADGRAPHWINDOW_HPP
 
 #include <gtkmm/builder.h>
 #include <gtkmm/button.h>
@@ -31,27 +31,27 @@
 
 namespace Ingen {
 
-namespace Client { class PatchModel; }
+namespace Client { class GraphModel; }
 
 namespace GUI {
 
-/** 'Add Subpatch' window.
+/** 'Load Graph' Window.
  *
  * Loaded from XML as a derived object.
  *
  * \ingroup GUI
  */
-class LoadPatchWindow : public Gtk::FileChooserDialog
+class LoadGraphWindow : public Gtk::FileChooserDialog
 {
 public:
-	LoadPatchWindow(BaseObjectType*                   cobject,
+	LoadGraphWindow(BaseObjectType*                   cobject,
 	                const Glib::RefPtr<Gtk::Builder>& xml);
 
 	void init(App& app) { _app = &app; }
 
-	void set_patch(SharedPtr<const Client::PatchModel> patch);
+	void set_graph(SharedPtr<const Client::GraphModel> graph);
 
-	void present(SharedPtr<const Client::PatchModel> patch,
+	void present(SharedPtr<const Client::GraphModel> graph,
 	             bool                                import,
 	             GraphObject::Properties             data);
 
@@ -73,7 +73,7 @@ private:
 
 	GraphObject::Properties _initial_data;
 
-	SharedPtr<const Client::PatchModel> _patch;
+	SharedPtr<const Client::GraphModel> _graph;
 
 	Gtk::Label*       _symbol_label;
 	Gtk::Entry*       _symbol_entry;
@@ -93,4 +93,4 @@ private:
 } // namespace GUI
 } // namespace Ingen
 
-#endif // INGEN_GUI_LOADSUBPATCHWINDOW_HPP
+#endif // INGEN_GUI_LOADGRAPHWINDOW_HPP
diff --git a/src/gui/LoadPluginWindow.cpp b/src/gui/LoadPluginWindow.cpp
index f5f7a7d7..c3e5b580 100644
--- a/src/gui/LoadPluginWindow.cpp
+++ b/src/gui/LoadPluginWindow.cpp
@@ -23,13 +23,13 @@
 
 #include "ingen/Interface.hpp"
 #include "ingen/client/ClientStore.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 
 #include "App.hpp"
 #include "LoadPluginWindow.hpp"
-#include "PatchCanvas.hpp"
-#include "PatchView.hpp"
-#include "PatchWindow.hpp"
+#include "GraphCanvas.hpp"
+#include "GraphView.hpp"
+#include "GraphWindow.hpp"
 
 #include "ingen_config.h"
 
@@ -115,10 +115,10 @@ LoadPluginWindow::LoadPluginWindow(BaseObjectType*                   cobject,
 }
 
 void
-LoadPluginWindow::present(SharedPtr<const PatchModel> patch,
+LoadPluginWindow::present(SharedPtr<const GraphModel> graph,
                           GraphObject::Properties     data)
 {
-	set_patch(patch);
+	set_graph(graph);
 	_initial_data = data;
 	Gtk::Window::present();
 }
@@ -134,7 +134,7 @@ LoadPluginWindow::name_changed()
 		const string sym = _name_entry->get_text();
 		if (!Raul::Symbol::is_valid(sym)) {
 			_add_button->property_sensitive() = false;
-		} else if (_app->store()->find(_patch->path().child(Raul::Symbol(sym)))
+		} else if (_app->store()->find(_graph->path().child(Raul::Symbol(sym)))
 		           != _app->store()->end()) {
 			_add_button->property_sensitive() = false;
 		} else {
@@ -151,21 +151,21 @@ LoadPluginWindow::name_cleared(Gtk::EntryIconPosition pos, const GdkEventButton*
 }
 #endif // HAVE_NEW_GTKMM
 
-/** Sets the patch controller for this window and initializes everything.
+/** Sets the graph controller for this window and initializes everything.
  *
  * This function MUST be called before using the window in any way!
  */
 void
-LoadPluginWindow::set_patch(SharedPtr<const PatchModel> patch)
+LoadPluginWindow::set_graph(SharedPtr<const GraphModel> graph)
 {
-	if (_patch) {
-		_patch = patch;
+	if (_graph) {
+		_graph = graph;
 		plugin_selection_changed();
 	} else {
-		_patch = patch;
+		_graph = graph;
 	}
 
-	/*if (patch->poly() <= 1)
+	/*if (graph->poly() <= 1)
 		_polyphonic_checkbutton->property_sensitive() = false;
 	else
 		_polyphonic_checkbutton->property_sensitive() = true;*/
@@ -174,8 +174,8 @@ LoadPluginWindow::set_patch(SharedPtr<const PatchModel> patch)
 /** Populates the plugin list on the first show.
  *
  * This is done here instead of construction time as the list population is
- * really expensive and bogs down creation of a patch.  This is especially
- * important when many patch notifications are sent at one time from the
+ * really expensive and bogs down creation of a graph.  This is especially
+ * important when many graph notifications are sent at one time from the
  * engine.
  */
 void
@@ -237,8 +237,8 @@ LoadPluginWindow::set_row(Gtk::TreeModel::Row&         row,
 	case Plugin::Internal:
 		row[_plugins_columns._col_type] = "Internal";
 		break;
-	case Plugin::Patch:
-		row[_plugins_columns._col_type] = "Patch";
+	case Plugin::Graph:
+		row[_plugins_columns._col_type] = "Graph";
 		break;
 	case Plugin::NIL:
 		row[_plugins_columns._col_type] = "?";
@@ -292,7 +292,7 @@ LoadPluginWindow::plugin_selection_changed()
 			boost::shared_ptr<const PluginModel> p = row.get_value(
 				_plugins_columns._col_plugin);
 			_name_offset = _app->store()->child_name_offset(
-					_patch->path(), p->default_block_symbol());
+					_graph->path(), p->default_block_symbol());
 			_name_entry->set_text(generate_module_name(p, _name_offset));
 			_name_entry->set_sensitive(true);
 		} else {
@@ -342,7 +342,7 @@ LoadPluginWindow::load_plugin(const Gtk::TreeModel::iterator& iter)
 
 		dialog.run();
 	} else {
-		Raul::Path path = _patch->path().child(Raul::Symbol::symbolify(name));
+		Raul::Path path = _graph->path().child(Raul::Symbol::symbolify(name));
 		Resource::Properties props = _initial_data;
 		props.insert(make_pair(uris.rdf_type,
 		                       uris.ingen_Block));
diff --git a/src/gui/LoadPluginWindow.hpp b/src/gui/LoadPluginWindow.hpp
index e9b874a2..ba574f12 100644
--- a/src/gui/LoadPluginWindow.hpp
+++ b/src/gui/LoadPluginWindow.hpp
@@ -28,16 +28,16 @@
 
 #include "raul/SharedPtr.hpp"
 
-#include "ingen_config.h"
 #include "ingen/GraphObject.hpp"
 #include "ingen/client/ClientStore.hpp"
+#include "ingen_config.h"
 
 #include "Window.hpp"
 
 namespace Ingen {
 
 namespace Client {
-class PatchModel;
+class GraphModel;
 class PluginModel;
 }
 
@@ -55,12 +55,12 @@ public:
 	LoadPluginWindow(BaseObjectType*                   cobject,
 	                 const Glib::RefPtr<Gtk::Builder>& xml);
 
-	void set_patch(SharedPtr<const Client::PatchModel> patch);
+	void set_graph(SharedPtr<const Client::GraphModel> graph);
 	void set_plugins(SharedPtr<const Client::ClientStore::Plugins> plugins);
 
 	void add_plugin(SharedPtr<const Client::PluginModel> plugin);
 
-	void present(SharedPtr<const Client::PatchModel> patch,
+	void present(SharedPtr<const Client::GraphModel> graph,
 	             GraphObject::Properties             data);
 
 protected:
@@ -128,7 +128,7 @@ private:
 
 	GraphObject::Properties _initial_data;
 
-	SharedPtr<const Client::PatchModel> _patch;
+	SharedPtr<const Client::GraphModel> _graph;
 
 	typedef std::map<Raul::URI, Gtk::TreeModel::iterator> Rows;
 	Rows _rows;
diff --git a/src/gui/MessagesWindow.hpp b/src/gui/MessagesWindow.hpp
index ad3f92a1..8167e30a 100644
--- a/src/gui/MessagesWindow.hpp
+++ b/src/gui/MessagesWindow.hpp
@@ -31,7 +31,7 @@ namespace GUI {
 /** Messages Window.
  *
  * Loaded from XML as a derived object.
- * This is shown when errors occur (e.g. during patch loading).
+ * This is shown when errors occur (e.g. during graph loading).
  *
  * \ingroup GUI
  */
diff --git a/src/gui/NewSubpatchWindow.cpp b/src/gui/NewSubgraphWindow.cpp
index 1124afb3..0cc8da7a 100644
--- a/src/gui/NewSubpatchWindow.cpp
+++ b/src/gui/NewSubgraphWindow.cpp
@@ -18,30 +18,30 @@
 
 #include "ingen/Interface.hpp"
 #include "ingen/client/ClientStore.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 
 #include "App.hpp"
-#include "NewSubpatchWindow.hpp"
-#include "PatchView.hpp"
+#include "NewSubgraphWindow.hpp"
+#include "GraphView.hpp"
 
 using namespace std;
 
 namespace Ingen {
 namespace GUI {
 
-NewSubpatchWindow::NewSubpatchWindow(BaseObjectType*                   cobject,
+NewSubgraphWindow::NewSubgraphWindow(BaseObjectType*                   cobject,
                                      const Glib::RefPtr<Gtk::Builder>& xml)
 	: Window(cobject)
 {
-	xml->get_widget("new_subpatch_name_entry", _name_entry);
-	xml->get_widget("new_subpatch_message_label", _message_label);
-	xml->get_widget("new_subpatch_polyphony_spinbutton", _poly_spinbutton);
-	xml->get_widget("new_subpatch_ok_button", _ok_button);
-	xml->get_widget("new_subpatch_cancel_button", _cancel_button);
+	xml->get_widget("new_subgraph_name_entry", _name_entry);
+	xml->get_widget("new_subgraph_message_label", _message_label);
+	xml->get_widget("new_subgraph_polyphony_spinbutton", _poly_spinbutton);
+	xml->get_widget("new_subgraph_ok_button", _ok_button);
+	xml->get_widget("new_subgraph_cancel_button", _cancel_button);
 
-	_name_entry->signal_changed().connect(sigc::mem_fun(this, &NewSubpatchWindow::name_changed));
-	_ok_button->signal_clicked().connect(sigc::mem_fun(this, &NewSubpatchWindow::ok_clicked));
-	_cancel_button->signal_clicked().connect(sigc::mem_fun(this, &NewSubpatchWindow::cancel_clicked));
+	_name_entry->signal_changed().connect(sigc::mem_fun(this, &NewSubgraphWindow::name_changed));
+	_ok_button->signal_clicked().connect(sigc::mem_fun(this, &NewSubgraphWindow::ok_clicked));
+	_cancel_button->signal_clicked().connect(sigc::mem_fun(this, &NewSubgraphWindow::cancel_clicked));
 
 	_ok_button->property_sensitive() = false;
 
@@ -49,35 +49,35 @@ NewSubpatchWindow::NewSubpatchWindow(BaseObjectType*                   cobject,
 }
 
 void
-NewSubpatchWindow::present(SharedPtr<const Client::PatchModel> patch,
+NewSubgraphWindow::present(SharedPtr<const Client::GraphModel> graph,
                            GraphObject::Properties             data)
 {
-	set_patch(patch);
+	set_graph(graph);
 	_initial_data = data;
 	Gtk::Window::present();
 }
 
-/** Sets the patch controller for this window and initializes everything.
+/** Sets the graph controller for this window and initializes everything.
  *
  * This function MUST be called before using the window in any way!
  */
 void
-NewSubpatchWindow::set_patch(SharedPtr<const Client::PatchModel> patch)
+NewSubgraphWindow::set_graph(SharedPtr<const Client::GraphModel> graph)
 {
-	_patch = patch;
+	_graph = graph;
 }
 
 /** Called every time the user types into the name input box.
  * Used to display warning messages, and enable/disable the OK button.
  */
 void
-NewSubpatchWindow::name_changed()
+NewSubgraphWindow::name_changed()
 {
 	string name = _name_entry->get_text();
 	if (!Raul::Symbol::is_valid(name)) {
 		_message_label->set_text("Name contains invalid characters.");
 		_ok_button->property_sensitive() = false;
-	} else if (_app->store()->find(_patch->path().child(Raul::Symbol(name)))
+	} else if (_app->store()->find(_graph->path().child(Raul::Symbol(name)))
 	           != _app->store()->end()) {
 		_message_label->set_text("An object already exists with that name.");
 		_ok_button->property_sensitive() = false;
@@ -86,31 +86,30 @@ NewSubpatchWindow::name_changed()
 		_ok_button->property_sensitive() = true;
 	}
 }
-
 void
-NewSubpatchWindow::ok_clicked()
+NewSubgraphWindow::ok_clicked()
 {
 	const uint32_t   poly = _poly_spinbutton->get_value_as_int();
-	const Raul::Path path = _patch->path().child(
+	const Raul::Path path = _graph->path().child(
 		Raul::Symbol::symbolify(_name_entry->get_text()));
 
-	// Create patch
+	// Create graph
 	Resource::Properties props;
-	props.insert(make_pair(_app->uris().rdf_type,        _app->uris().ingen_Patch));
+	props.insert(make_pair(_app->uris().rdf_type,        _app->uris().ingen_Graph));
 	props.insert(make_pair(_app->uris().ingen_polyphony, _app->forge().make(int32_t(poly))));
 	props.insert(make_pair(_app->uris().ingen_enabled,   _app->forge().make(bool(true))));
 	_app->interface()->put(GraphObject::path_to_uri(path), props, Resource::INTERNAL);
 
 	// Set external (block perspective) properties
 	props = _initial_data;
-	props.insert(make_pair(_app->uris().rdf_type, _app->uris().ingen_Patch));
+	props.insert(make_pair(_app->uris().rdf_type, _app->uris().ingen_Graph));
 	_app->interface()->put(GraphObject::path_to_uri(path), _initial_data, Resource::EXTERNAL);
 
 	hide();
 }
 
 void
-NewSubpatchWindow::cancel_clicked()
+NewSubgraphWindow::cancel_clicked()
 {
 	hide();
 }
diff --git a/src/gui/NewSubpatchWindow.hpp b/src/gui/NewSubgraphWindow.hpp
index 20a27dc6..721a0916 100644
--- a/src/gui/NewSubpatchWindow.hpp
+++ b/src/gui/NewSubgraphWindow.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_GUI_NEWSUBPATCHWINDOW_HPP
-#define INGEN_GUI_NEWSUBPATCHWINDOW_HPP
+#ifndef INGEN_GUI_NEWSUBGRAPHWINDOW_HPP
+#define INGEN_GUI_NEWSUBGRAPHWINDOW_HPP
 
 #include <gtkmm/builder.h>
 #include <gtkmm/button.h>
@@ -31,25 +31,25 @@
 
 namespace Ingen {
 
-namespace Client { class PatchModel; }
+namespace Client { class GraphModel; }
 
 namespace GUI {
 
-/** 'New Subpatch' window.
+/** 'New Subgraph' window.
  *
  * Loaded from XML as a derived object.
  *
  * \ingroup GUI
  */
-class NewSubpatchWindow : public Window
+class NewSubgraphWindow : public Window
 {
 public:
-	NewSubpatchWindow(BaseObjectType*                   cobject,
+	NewSubgraphWindow(BaseObjectType*                   cobject,
 	                  const Glib::RefPtr<Gtk::Builder>& xml);
 
-	void set_patch(SharedPtr<const Client::PatchModel> patch);
+	void set_graph(SharedPtr<const Client::GraphModel> graph);
 
-	void present(SharedPtr<const Client::PatchModel> patch,
+	void present(SharedPtr<const Client::GraphModel> graph,
 	             GraphObject::Properties             data);
 
 private:
@@ -58,7 +58,7 @@ private:
 	void cancel_clicked();
 
 	GraphObject::Properties             _initial_data;
-	SharedPtr<const Client::PatchModel> _patch;
+	SharedPtr<const Client::GraphModel> _graph;
 
 	Gtk::Entry*      _name_entry;
 	Gtk::Label*      _message_label;
@@ -70,4 +70,4 @@ private:
 } // namespace GUI
 } // namespace Ingen
 
-#endif // INGEN_GUI_NEWSUBPATCHWINDOW_HPP
+#endif // INGEN_GUI_NEWSUBGRAPHWINDOW_HPP
diff --git a/src/gui/NodeModule.cpp b/src/gui/NodeModule.cpp
index bbd569fc..5be945ce 100644
--- a/src/gui/NodeModule.cpp
+++ b/src/gui/NodeModule.cpp
@@ -24,7 +24,7 @@
 #include "ingen/Interface.hpp"
 #include "ingen/Log.hpp"
 #include "ingen/client/BlockModel.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 #include "ingen/client/PluginModel.hpp"
 #include "ingen/client/PluginUI.hpp"
 #include "raul/Atom.hpp"
@@ -33,11 +33,11 @@
 #include "Configuration.hpp"
 #include "NodeMenu.hpp"
 #include "NodeModule.hpp"
-#include "PatchCanvas.hpp"
-#include "PatchWindow.hpp"
+#include "GraphCanvas.hpp"
+#include "GraphWindow.hpp"
 #include "Port.hpp"
 #include "RenameWindow.hpp"
-#include "SubpatchModule.hpp"
+#include "SubgraphModule.hpp"
 #include "WidgetFactory.hpp"
 #include "WindowFactory.hpp"
 
@@ -49,7 +49,7 @@ using namespace Client;
 
 namespace GUI {
 
-NodeModule::NodeModule(PatchCanvas&                canvas,
+NodeModule::NodeModule(GraphCanvas&                canvas,
                        SharedPtr<const BlockModel> block)
 	: Ganv::Module(canvas, block->path().symbol(), 0, 0, true)
 	, _block(block)
@@ -98,14 +98,14 @@ NodeModule::show_menu(GdkEventButton* ev)
 }
 
 NodeModule*
-NodeModule::create(PatchCanvas&                canvas,
+NodeModule::create(GraphCanvas&                canvas,
                    SharedPtr<const BlockModel> block,
                    bool                        human)
 {
-	SharedPtr<const PatchModel> patch = PtrCast<const PatchModel>(block);
+	SharedPtr<const GraphModel> graph = PtrCast<const GraphModel>(block);
 	
-	NodeModule* ret = (patch)
-		? new SubpatchModule(canvas, patch)
+	NodeModule* ret = (graph)
+		? new SubgraphModule(canvas, graph)
 		: new NodeModule(canvas, block);
 
 	for (GraphObject::Properties::const_iterator m = block->properties().begin();
@@ -127,7 +127,7 @@ NodeModule::create(PatchCanvas&                canvas,
 App&
 NodeModule::app() const
 {
-	return ((PatchCanvas*)canvas())->app();
+	return ((GraphCanvas*)canvas())->app();
 }
 
 void
@@ -432,7 +432,7 @@ NodeModule::set_selected(gboolean b)
 		Ganv::Module::set_selected(b);
 		#if 0
 		if (b) {
-			PatchWindow* win = app().window_factory()->parent_patch_window(block());
+			GraphWindow* win = app().window_factory()->parent_graph_window(block());
 			if (win) {
 				std::string doc;
 				bool        html = false;
diff --git a/src/gui/NodeModule.hpp b/src/gui/NodeModule.hpp
index 73295d1a..2d63b047 100644
--- a/src/gui/NodeModule.hpp
+++ b/src/gui/NodeModule.hpp
@@ -33,11 +33,11 @@ namespace Ingen { namespace Client {
 namespace Ingen {
 namespace GUI {
 
-class PatchCanvas;
+class GraphCanvas;
 class Port;
 class NodeMenu;
 
-/** A module in a patch.
+/** A module in a graphn.
  *
  * This base class is extended for various types of modules.
  *
@@ -47,7 +47,7 @@ class NodeModule : public Ganv::Module
 {
 public:
 	static NodeModule* create(
-		PatchCanvas&                        canvas,
+		GraphCanvas&                        canvas,
 		SharedPtr<const Client::BlockModel> block,
 		bool                                human_names);
 
@@ -66,7 +66,7 @@ public:
 	SharedPtr<const Client::BlockModel> block() const { return _block; }
 
 protected:
-	NodeModule(PatchCanvas& canvas, SharedPtr<const Client::BlockModel> block);
+	NodeModule(GraphCanvas& canvas, SharedPtr<const Client::BlockModel> block);
 
 	virtual bool on_double_click(GdkEventButton* ev);
 
diff --git a/src/gui/ObjectMenu.hpp b/src/gui/ObjectMenu.hpp
index 6cb20e70..c4648443 100644
--- a/src/gui/ObjectMenu.hpp
+++ b/src/gui/ObjectMenu.hpp
@@ -31,7 +31,7 @@ namespace GUI {
 
 class ObjectControlWindow;
 class ObjectPropertiesWindow;
-class PatchCanvas;
+class GraphCanvas;
 
 /** Menu for a Object.
  *
diff --git a/src/gui/PatchTreeWindow.cpp b/src/gui/PatchTreeWindow.cpp
deleted file mode 100644
index 00b96926..00000000
--- a/src/gui/PatchTreeWindow.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-/*
-  This file is part of Ingen.
-  Copyright 2007-2012 David Robillard <http://drobilla.net/>
-
-  Ingen is free software: you can redistribute it and/or modify it under the
-  terms of the GNU Affero General Public License as published by the Free
-  Software Foundation, either version 3 of the License, or any later version.
-
-  Ingen is distributed in the hope that it will be useful, but WITHOUT ANY
-  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-  A PARTICULAR PURPOSE.  See the GNU Affero General Public License for details.
-
-  You should have received a copy of the GNU Affero General Public License
-  along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "App.hpp"
-#include "PatchTreeWindow.hpp"
-#include "SubpatchModule.hpp"
-#include "WindowFactory.hpp"
-#include "ingen/Interface.hpp"
-#include "ingen/Log.hpp"
-#include "ingen/client/ClientStore.hpp"
-#include "ingen/client/PatchModel.hpp"
-#include "raul/Path.hpp"
-
-using namespace std;
-
-namespace Ingen {
-
-using namespace Client;
-
-namespace GUI {
-
-PatchTreeWindow::PatchTreeWindow(BaseObjectType*                   cobject,
-                                 const Glib::RefPtr<Gtk::Builder>& xml)
-	: Window(cobject)
-	, _app(NULL)
-	, _enable_signal(true)
-{
-	xml->get_widget_derived("patches_treeview", _patches_treeview);
-
-	_patch_treestore = Gtk::TreeStore::create(_patch_tree_columns);
-	_patches_treeview->set_window(this);
-	_patches_treeview->set_model(_patch_treestore);
-	Gtk::TreeViewColumn* name_col = Gtk::manage(new Gtk::TreeViewColumn(
-		"Patch", _patch_tree_columns.name_col));
-	Gtk::TreeViewColumn* enabled_col = Gtk::manage(new Gtk::TreeViewColumn(
-		"Run", _patch_tree_columns.enabled_col));
-	name_col->set_resizable(true);
-	name_col->set_expand(true);
-
-	_patches_treeview->append_column(*name_col);
-	_patches_treeview->append_column(*enabled_col);
-	Gtk::CellRendererToggle* enabled_renderer = dynamic_cast<Gtk::CellRendererToggle*>(
-		_patches_treeview->get_column_cell_renderer(1));
-	enabled_renderer->property_activatable() = true;
-
-	_patch_tree_selection = _patches_treeview->get_selection();
-
-	_patches_treeview->signal_row_activated().connect(
-		sigc::mem_fun(this, &PatchTreeWindow::event_patch_activated));
-	enabled_renderer->signal_toggled().connect(
-		sigc::mem_fun(this, &PatchTreeWindow::event_patch_enabled_toggled));
-
-	_patches_treeview->columns_autosize();
-}
-
-void
-PatchTreeWindow::init(App& app, ClientStore& store)
-{
-	_app = &app;
-	store.signal_new_object().connect(
-		sigc::mem_fun(this, &PatchTreeWindow::new_object));
-}
-
-void
-PatchTreeWindow::new_object(SharedPtr<ObjectModel> object)
-{
-	SharedPtr<PatchModel> patch = PtrCast<PatchModel>(object);
-	if (patch)
-		add_patch(patch);
-}
-
-void
-PatchTreeWindow::add_patch(SharedPtr<PatchModel> pm)
-{
-	if (!pm->parent()) {
-		Gtk::TreeModel::iterator iter = _patch_treestore->append();
-		Gtk::TreeModel::Row row = *iter;
-		if (pm->path().is_root()) {
-			row[_patch_tree_columns.name_col] = _app->interface()->uri();
-		} else {
-			row[_patch_tree_columns.name_col] = pm->symbol().c_str();
-		}
-		row[_patch_tree_columns.enabled_col] = pm->enabled();
-		row[_patch_tree_columns.patch_model_col] = pm;
-		_patches_treeview->expand_row(_patch_treestore->get_path(iter), true);
-	} else {
-		Gtk::TreeModel::Children children = _patch_treestore->children();
-		Gtk::TreeModel::iterator c = find_patch(children, pm->parent());
-
-		if (c != children.end()) {
-			Gtk::TreeModel::iterator iter = _patch_treestore->append(c->children());
-			Gtk::TreeModel::Row row = *iter;
-			row[_patch_tree_columns.name_col] = pm->symbol().c_str();
-			row[_patch_tree_columns.enabled_col] = pm->enabled();
-			row[_patch_tree_columns.patch_model_col] = pm;
-			_patches_treeview->expand_row(_patch_treestore->get_path(iter), true);
-		}
-	}
-
-	pm->signal_property().connect(
-		sigc::bind(sigc::mem_fun(this, &PatchTreeWindow::patch_property_changed),
-		           pm));
-
-	pm->signal_moved().connect(
-		sigc::bind(sigc::mem_fun(this, &PatchTreeWindow::patch_moved),
-		           pm));
-
-	pm->signal_destroyed().connect(
-		sigc::bind(sigc::mem_fun(this, &PatchTreeWindow::remove_patch),
-		           pm));
-}
-
-void
-PatchTreeWindow::remove_patch(SharedPtr<PatchModel> pm)
-{
-	Gtk::TreeModel::iterator i = find_patch(_patch_treestore->children(), pm);
-	if (i != _patch_treestore->children().end())
-		_patch_treestore->erase(i);
-}
-
-Gtk::TreeModel::iterator
-PatchTreeWindow::find_patch(
-		Gtk::TreeModel::Children       root,
-		SharedPtr<Client::ObjectModel> patch)
-{
-	for (Gtk::TreeModel::iterator c = root.begin(); c != root.end(); ++c) {
-		SharedPtr<PatchModel> pm = (*c)[_patch_tree_columns.patch_model_col];
-		if (patch == pm) {
-			return c;
-		} else if ((*c)->children().size() > 0) {
-			Gtk::TreeModel::iterator ret = find_patch(c->children(), patch);
-			if (ret != c->children().end())
-				return ret;
-		}
-	}
-	return root.end();
-}
-
-/** Show the context menu for the selected patch in the patches treeview.
- */
-void
-PatchTreeWindow::show_patch_menu(GdkEventButton* ev)
-{
-	Gtk::TreeModel::iterator active = _patch_tree_selection->get_selected();
-	if (active) {
-		Gtk::TreeModel::Row row = *active;
-		SharedPtr<PatchModel> pm = row[_patch_tree_columns.patch_model_col];
-		if (pm) {
-			_app->log().warn("TODO: patch menu from tree window");
-		}
-	}
-}
-
-void
-PatchTreeWindow::event_patch_activated(const Gtk::TreeModel::Path& path, Gtk::TreeView::Column* col)
-{
-	Gtk::TreeModel::iterator active = _patch_treestore->get_iter(path);
-	Gtk::TreeModel::Row row = *active;
-	SharedPtr<PatchModel> pm = row[_patch_tree_columns.patch_model_col];
-
-	_app->window_factory()->present_patch(pm);
-}
-
-void
-PatchTreeWindow::event_patch_enabled_toggled(const Glib::ustring& path_str)
-{
-	Gtk::TreeModel::Path path(path_str);
-	Gtk::TreeModel::iterator active = _patch_treestore->get_iter(path);
-	Gtk::TreeModel::Row row = *active;
-
-	SharedPtr<PatchModel> pm = row[_patch_tree_columns.patch_model_col];
-	assert(pm);
-
-	if (_enable_signal)
-		_app->interface()->set_property(
-			pm->uri(),
-			_app->uris().ingen_enabled,
-			_app->forge().make((bool)!pm->enabled()));
-}
-
-void
-PatchTreeWindow::patch_property_changed(const Raul::URI&      key,
-                                        const Raul::Atom&     value,
-                                        SharedPtr<PatchModel> patch)
-{
-	const URIs& uris = _app->uris();
-	_enable_signal = false;
-	if (key == uris.ingen_enabled && value.type() == uris.forge.Bool) {
-		Gtk::TreeModel::iterator i = find_patch(_patch_treestore->children(), patch);
-		if (i != _patch_treestore->children().end()) {
-			Gtk::TreeModel::Row row = *i;
-			row[_patch_tree_columns.enabled_col] = value.get_bool();
-		} else {
-			_app->log().error(Raul::fmt("Unable to find patch %1%\n")
-			                  % patch->path());
-		}
-	}
-	_enable_signal = true;
-}
-
-void
-PatchTreeWindow::patch_moved(SharedPtr<PatchModel> patch)
-{
-	_enable_signal = false;
-
-	Gtk::TreeModel::iterator i
-		= find_patch(_patch_treestore->children(), patch);
-
-	if (i != _patch_treestore->children().end()) {
-		Gtk::TreeModel::Row row = *i;
-		row[_patch_tree_columns.name_col] = patch->symbol().c_str();
-	} else {
-		_app->log().error(Raul::fmt("Unable to find patch %1%\n")
-		                  % patch->path());
-	}
-
-	_enable_signal = true;
-}
-
-} // namespace GUI
-} // namespace Ingen
diff --git a/src/gui/Port.cpp b/src/gui/Port.cpp
index 88d81fcd..f747234a 100644
--- a/src/gui/Port.cpp
+++ b/src/gui/Port.cpp
@@ -20,12 +20,12 @@
 #include "ganv/Module.hpp"
 #include "ingen/Interface.hpp"
 #include "ingen/Log.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 #include "ingen/client/PortModel.hpp"
 
 #include "App.hpp"
 #include "Configuration.hpp"
-#include "PatchWindow.hpp"
+#include "GraphWindow.hpp"
 #include "Port.hpp"
 #include "PortMenu.hpp"
 #include "WidgetFactory.hpp"
@@ -156,7 +156,7 @@ Port::on_value_changed(GVariant* value)
 	}
 
 	if (_entered) {
-		PatchBox* box = get_patch_box();
+		GraphBox* box = get_graph_box();
 		if (box) {
 			box->show_port_status(model().get(), atom);
 		}
@@ -202,17 +202,17 @@ Port::build_enum_menu()
 bool
 Port::on_event(GdkEvent* ev)
 {
-	PatchBox* box = NULL;
+	GraphBox* box = NULL;
 	switch (ev->type) {
 	case GDK_ENTER_NOTIFY:
 		_entered = true;
-		if ((box = get_patch_box())) {
+		if ((box = get_graph_box())) {
 			box->object_entered(model().get());
 		}
 		break;
 	case GDK_LEAVE_NOTIFY:
 		_entered = false;
-		if ((box = get_patch_box())) {
+		if ((box = get_graph_box())) {
 			box->object_left(model().get());
 		}
 		break;
@@ -306,15 +306,15 @@ Port::disconnected_from(SharedPtr<PortModel> port)
 	}
 }
 
-PatchBox*
-Port::get_patch_box() const
+GraphBox*
+Port::get_graph_box() const
 {
-	SharedPtr<const PatchModel> patch = PtrCast<const PatchModel>(model()->parent());
-	if (!patch) {
-		patch = PtrCast<const PatchModel>(model()->parent()->parent());
+	SharedPtr<const GraphModel> graph = PtrCast<const GraphModel>(model()->parent());
+	if (!graph) {
+		graph = PtrCast<const GraphModel>(model()->parent()->parent());
 	}
 
-	return _app.window_factory()->patch_box(patch);
+	return _app.window_factory()->graph_box(graph);
 }
 
 void
@@ -355,7 +355,7 @@ Port::set_selected(gboolean b)
 		SharedPtr<const PortModel> pm = _port_model.lock();
 		if (pm && b) {
 			SharedPtr<const BlockModel> block = PtrCast<BlockModel>(pm->parent());
-			PatchWindow* win = _app.window_factory()->parent_patch_window(block);
+			GraphWindow* win = _app.window_factory()->parent_graph_window(block);
 			if (win && block->plugin_model()) {
 				const std::string& doc = block->plugin_model()->port_documentation(
 					pm->index());
diff --git a/src/gui/Port.hpp b/src/gui/Port.hpp
index 6552ba8d..2aab66eb 100644
--- a/src/gui/Port.hpp
+++ b/src/gui/Port.hpp
@@ -38,7 +38,7 @@ namespace Client { class PortModel; }
 namespace GUI {
 
 class App;
-class PatchBox;
+class GraphBox;
 
 /** A Port on an Module.
  *
@@ -75,7 +75,7 @@ private:
 	     bool                               flip = false);
 
 	Gtk::Menu* build_enum_menu();
-	PatchBox* get_patch_box() const;
+	GraphBox* get_graph_box() const;
 
 	void property_changed(const Raul::URI& key, const Raul::Atom& value);
 	void moved();
diff --git a/src/gui/PortMenu.cpp b/src/gui/PortMenu.cpp
index a23e3b84..3b51976f 100644
--- a/src/gui/PortMenu.cpp
+++ b/src/gui/PortMenu.cpp
@@ -17,7 +17,7 @@
 #include <math.h>
 
 #include "ingen/Interface.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 #include "ingen/client/PortModel.hpp"
 #include "raul/SharedPtr.hpp"
 
@@ -34,7 +34,7 @@ namespace GUI {
 PortMenu::PortMenu(BaseObjectType*                   cobject,
                    const Glib::RefPtr<Gtk::Builder>& xml)
 	: ObjectMenu(cobject, xml)
-	, _is_patch_port(false)
+	, _is_graph_port(false)
 {
 	xml->get_widget("object_menu", _port_menu);
 	xml->get_widget("port_set_min_menuitem", _set_min_menuitem);
@@ -44,12 +44,12 @@ PortMenu::PortMenu(BaseObjectType*                   cobject,
 }
 
 void
-PortMenu::init(App& app, SharedPtr<const PortModel> port, bool is_patch_port)
+PortMenu::init(App& app, SharedPtr<const PortModel> port, bool is_graph_port)
 {
 	const URIs& uris = app.uris();
 
 	ObjectMenu::init(app, port);
-	_is_patch_port = is_patch_port;
+	_is_graph_port = is_graph_port;
 
 	_set_min_menuitem->signal_activate().connect(
 		sigc::mem_fun(this, &PortMenu::on_menu_set_min));
@@ -64,9 +64,9 @@ PortMenu::init(App& app, SharedPtr<const PortModel> port, bool is_patch_port)
 		sigc::mem_fun(this, &PortMenu::on_menu_expose));
 
 	const bool is_control  = app.can_control(port.get()) && port->is_numeric();
-	const bool is_on_patch = PtrCast<PatchModel>(port->parent());
+	const bool is_on_graph = PtrCast<GraphModel>(port->parent());
 
-	if (!_is_patch_port) {
+	if (!_is_graph_port) {
 		_polyphonic_menuitem->set_sensitive(false);
 		_rename_menuitem->set_sensitive(false);
 		_destroy_menuitem->set_sensitive(false);
@@ -76,10 +76,10 @@ PortMenu::init(App& app, SharedPtr<const PortModel> port, bool is_patch_port)
 		_polyphonic_menuitem->hide();
 	}
 
-	_reset_range_menuitem->set_visible(is_control && !is_on_patch);
+	_reset_range_menuitem->set_visible(is_control && !is_on_graph);
 	_set_max_menuitem->set_visible(is_control);
 	_set_min_menuitem->set_visible(is_control);
-	_expose_menuitem->set_visible(!is_on_patch);
+	_expose_menuitem->set_visible(!is_on_graph);
 	_learn_menuitem->set_visible(is_control);
 	_unlearn_menuitem->set_visible(is_control);
 
@@ -89,7 +89,7 @@ PortMenu::init(App& app, SharedPtr<const PortModel> port, bool is_patch_port)
 void
 PortMenu::on_menu_disconnect()
 {
-	if (_is_patch_port) {
+	if (_is_graph_port) {
 		_app->interface()->disconnect_all(
 				_object->parent()->path(), _object->path());
 	} else {
diff --git a/src/gui/PortMenu.hpp b/src/gui/PortMenu.hpp
index 598afaa5..34f2c315 100644
--- a/src/gui/PortMenu.hpp
+++ b/src/gui/PortMenu.hpp
@@ -41,7 +41,7 @@ public:
 
 	void init(App&                               app,
 	          SharedPtr<const Client::PortModel> port,
-	          bool                               is_patch_port = false);
+	          bool                               is_graph_port = false);
 
 private:
 	void on_menu_disconnect();
@@ -56,7 +56,7 @@ private:
 	Gtk::MenuItem* _reset_range_menuitem;
 	Gtk::MenuItem* _expose_menuitem;
 
-	bool _is_patch_port;
+	bool _is_graph_port;
 };
 
 } // namespace GUI
diff --git a/src/gui/SubpatchModule.cpp b/src/gui/SubgraphModule.cpp
index efd29805..4860098e 100644
--- a/src/gui/SubpatchModule.cpp
+++ b/src/gui/SubgraphModule.cpp
@@ -18,14 +18,14 @@
 #include <utility>
 
 #include "ingen/Interface.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 
 #include "App.hpp"
 #include "NodeModule.hpp"
-#include "PatchCanvas.hpp"
-#include "PatchWindow.hpp"
+#include "GraphCanvas.hpp"
+#include "GraphWindow.hpp"
 #include "Port.hpp"
-#include "SubpatchModule.hpp"
+#include "SubgraphModule.hpp"
 #include "WindowFactory.hpp"
 
 using namespace std;
@@ -36,31 +36,31 @@ using namespace Client;
 
 namespace GUI {
 
-SubpatchModule::SubpatchModule(PatchCanvas&                canvas,
-                               SharedPtr<const PatchModel> patch)
-	: NodeModule(canvas, patch)
-	, _patch(patch)
+SubgraphModule::SubgraphModule(GraphCanvas&                canvas,
+                               SharedPtr<const GraphModel> graph)
+	: NodeModule(canvas, graph)
+	, _graph(graph)
 {
-	assert(patch);
+	assert(graph);
 }
 
 bool
-SubpatchModule::on_double_click(GdkEventButton* event)
+SubgraphModule::on_double_click(GdkEventButton* event)
 {
-	assert(_patch);
+	assert(_graph);
 
-	SharedPtr<PatchModel> parent = PtrCast<PatchModel>(_patch->parent());
+	SharedPtr<GraphModel> parent = PtrCast<GraphModel>(_graph->parent());
 
-	PatchWindow* const preferred = ( (parent && (event->state & GDK_SHIFT_MASK))
+	GraphWindow* const preferred = ( (parent && (event->state & GDK_SHIFT_MASK))
 		? NULL
-		: app().window_factory()->patch_window(parent) );
+		: app().window_factory()->graph_window(parent) );
 
-	app().window_factory()->present_patch(_patch, preferred);
+	app().window_factory()->present_graph(_graph, preferred);
 	return true;
 }
 
 void
-SubpatchModule::store_location(double ax, double ay)
+SubgraphModule::store_location(double ax, double ay)
 {
 	const URIs& uris = app().uris();
 
@@ -82,27 +82,27 @@ SubpatchModule::store_location(double ax, double ay)
 	}
 }
 
-/** Browse to this patch in current (parent's) window
+/** Browse to this graph in current (parent's) window
  * (unless an existing window is displaying it)
  */
 void
-SubpatchModule::browse_to_patch()
+SubgraphModule::browse_to_graph()
 {
-	assert(_patch->parent());
+	assert(_graph->parent());
 
-	SharedPtr<PatchModel> parent = PtrCast<PatchModel>(_patch->parent());
+	SharedPtr<GraphModel> parent = PtrCast<GraphModel>(_graph->parent());
 
-	PatchWindow* const preferred = (parent)
-		? app().window_factory()->patch_window(parent)
+	GraphWindow* const preferred = (parent)
+		? app().window_factory()->graph_window(parent)
 		: NULL;
 
-	app().window_factory()->present_patch(_patch, preferred);
+	app().window_factory()->present_graph(_graph, preferred);
 }
 
 void
-SubpatchModule::menu_remove()
+SubgraphModule::menu_remove()
 {
-	app().interface()->del(_patch->uri());
+	app().interface()->del(_graph->uri());
 }
 
 } // namespace GUI
diff --git a/src/gui/SubpatchModule.hpp b/src/gui/SubgraphModule.hpp
index 8d7dbecc..569e0fd8 100644
--- a/src/gui/SubpatchModule.hpp
+++ b/src/gui/SubgraphModule.hpp
@@ -14,51 +14,51 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_GUI_SUBPATCHMODULE_HPP
-#define INGEN_GUI_SUBPATCHMODULE_HPP
+#ifndef INGEN_GUI_SUBGRAPHMODULE_HPP
+#define INGEN_GUI_SUBGRAPHMODULE_HPP
 
 #include "raul/SharedPtr.hpp"
 
 #include "NodeModule.hpp"
-#include "PatchPortModule.hpp"
+#include "GraphPortModule.hpp"
 
 namespace Ingen { namespace Client {
-	class PatchModel;
-	class PatchWindow;
+	class GraphModel;
+	class GraphWindow;
 	class PortModel;
 } }
 
 namespace Ingen {
 namespace GUI {
 
-class PatchCanvas;
+class GraphCanvas;
 
-/** A module to represent a subpatch
+/** A module to represent a subgraph
  *
  * \ingroup GUI
  */
-class SubpatchModule : public NodeModule
+class SubgraphModule : public NodeModule
 {
 public:
-	SubpatchModule(PatchCanvas&                        canvas,
-	               SharedPtr<const Client::PatchModel> controller);
+	SubgraphModule(GraphCanvas&                        canvas,
+	               SharedPtr<const Client::GraphModel> controller);
 
-	virtual ~SubpatchModule() {}
+	virtual ~SubgraphModule() {}
 
 	bool on_double_click(GdkEventButton* ev);
 
 	void store_location(double x, double y);
 
-	void browse_to_patch();
+	void browse_to_graph();
 	void menu_remove();
 
-	SharedPtr<const Client::PatchModel> patch() const { return _patch; }
+	SharedPtr<const Client::GraphModel> graph() const { return _graph; }
 
 protected:
-	SharedPtr<const Client::PatchModel> _patch;
+	SharedPtr<const Client::GraphModel> _graph;
 };
 
 } // namespace GUI
 } // namespace Ingen
 
-#endif // INGEN_GUI_SUBPATCHMODULE_HPP
+#endif // INGEN_GUI_SUBGRAPHMODULE_HPP
diff --git a/src/gui/ThreadedLoader.cpp b/src/gui/ThreadedLoader.cpp
index bc7aa19c..cec9a4c9 100644
--- a/src/gui/ThreadedLoader.cpp
+++ b/src/gui/ThreadedLoader.cpp
@@ -19,7 +19,7 @@
 #include "ingen/Log.hpp"
 #include "ingen/Module.hpp"
 #include "ingen/World.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 
 #include "App.hpp"
 #include "ThreadedLoader.hpp"
@@ -39,7 +39,7 @@ ThreadedLoader::ThreadedLoader(App& app, SharedPtr<Interface> engine)
 	if (parser()) {
 		start();
 	} else {
-		app.log().warn("Parser unavailable, patch loading disabled\n");
+		app.log().warn("Parser unavailable, graph loading disabled\n");
 	}
 }
 
@@ -74,7 +74,7 @@ ThreadedLoader::_run()
 }
 
 void
-ThreadedLoader::load_patch(bool                              merge,
+ThreadedLoader::load_graph(bool                              merge,
                            const Glib::ustring&              document_uri,
                            optional<Raul::Path>              engine_parent,
                            optional<Raul::Symbol>            engine_symbol,
@@ -108,13 +108,13 @@ ThreadedLoader::load_patch(bool                              merge,
 }
 
 void
-ThreadedLoader::save_patch(SharedPtr<const Client::PatchModel> model,
+ThreadedLoader::save_graph(SharedPtr<const Client::GraphModel> model,
                            const string&                       filename)
 {
 	_mutex.lock();
 
 	_events.push_back(sigc::hide_return(sigc::bind(
-		sigc::mem_fun(this, &ThreadedLoader::save_patch_event),
+		sigc::mem_fun(this, &ThreadedLoader::save_graph_event),
 		model, filename)));
 
 	_mutex.unlock();
@@ -122,7 +122,7 @@ ThreadedLoader::save_patch(SharedPtr<const Client::PatchModel> model,
 }
 
 void
-ThreadedLoader::save_patch_event(SharedPtr<const Client::PatchModel> model,
+ThreadedLoader::save_graph_event(SharedPtr<const Client::GraphModel> model,
                                  const string&                       filename)
 {
 	if (_app.serialiser()) {
diff --git a/src/gui/ThreadedLoader.hpp b/src/gui/ThreadedLoader.hpp
index 273c72f9..162e7cc7 100644
--- a/src/gui/ThreadedLoader.hpp
+++ b/src/gui/ThreadedLoader.hpp
@@ -33,11 +33,11 @@
 namespace Ingen {
 namespace GUI {
 
-/** Thread for loading patch files.
+/** Thread for loading graph files.
  *
  * This is a seperate thread so it can send all the loading message without
  * blocking everything else, so the app can respond to the incoming events
- * caused as a result of the patch loading, while the patch loads.
+ * caused as a result of the graph loading, while the graph loads.
  *
  * Implemented as a slave with a list of closures (events) which processes
  * all events in the (mutex protected) list each time it's whipped.
@@ -52,19 +52,19 @@ public:
 
 	~ThreadedLoader();
 
-	void load_patch(bool                                     merge,
+	void load_graph(bool                                     merge,
                     const Glib::ustring&                     document_uri,
 	                boost::optional<Raul::Path>              engine_parent,
                     boost::optional<Raul::Symbol>            engine_symbol,
                     boost::optional<GraphObject::Properties> engine_data);
 
-	void save_patch(SharedPtr<const Client::PatchModel> model,
+	void save_graph(SharedPtr<const Client::GraphModel> model,
 	                const std::string&                  filename);
 
 	SharedPtr<Serialisation::Parser> parser();
 
 private:
-	void save_patch_event(SharedPtr<const Client::PatchModel> model,
+	void save_graph_event(SharedPtr<const Client::GraphModel> model,
 	                      const std::string&                  filename);
 
 	/** Returns nothing and takes no parameters (because they have all been bound) */
diff --git a/src/gui/WindowFactory.cpp b/src/gui/WindowFactory.cpp
index 1f0e0310..884313fd 100644
--- a/src/gui/WindowFactory.cpp
+++ b/src/gui/WindowFactory.cpp
@@ -16,14 +16,14 @@
 
 #include <string>
 
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 
 #include "App.hpp"
-#include "LoadPatchWindow.hpp"
+#include "LoadGraphWindow.hpp"
 #include "LoadPluginWindow.hpp"
-#include "NewSubpatchWindow.hpp"
-#include "PatchView.hpp"
-#include "PatchWindow.hpp"
+#include "NewSubgraphWindow.hpp"
+#include "GraphView.hpp"
+#include "GraphWindow.hpp"
 #include "PropertiesWindow.hpp"
 #include "RenameWindow.hpp"
 #include "WidgetFactory.hpp"
@@ -41,58 +41,58 @@ WindowFactory::WindowFactory(App& app)
 	: _app(app)
 	, _main_box(NULL)
 	, _load_plugin_win(NULL)
-	, _load_patch_win(NULL)
-	, _new_subpatch_win(NULL)
+	, _load_graph_win(NULL)
+	, _new_subgraph_win(NULL)
 	, _properties_win(NULL)
 {
 	WidgetFactory::get_widget_derived("load_plugin_win", _load_plugin_win);
-	WidgetFactory::get_widget_derived("load_patch_win", _load_patch_win);
-	WidgetFactory::get_widget_derived("new_subpatch_win", _new_subpatch_win);
+	WidgetFactory::get_widget_derived("load_graph_win", _load_graph_win);
+	WidgetFactory::get_widget_derived("new_subgraph_win", _new_subgraph_win);
 	WidgetFactory::get_widget_derived("properties_win", _properties_win);
 	WidgetFactory::get_widget_derived("rename_win", _rename_win);
 
 	_load_plugin_win->init_window(app);
-	_load_patch_win->init(app);
-	_new_subpatch_win->init_window(app);
+	_load_graph_win->init(app);
+	_new_subgraph_win->init_window(app);
 	_properties_win->init_window(app);
 	_rename_win->init_window(app);
 }
 
 WindowFactory::~WindowFactory()
 {
-	for (PatchWindowMap::iterator i = _patch_windows.begin();
-	     i != _patch_windows.end(); ++i)
+	for (GraphWindowMap::iterator i = _graph_windows.begin();
+	     i != _graph_windows.end(); ++i)
 		delete i->second;
 }
 
 void
 WindowFactory::clear()
 {
-	for (PatchWindowMap::iterator i = _patch_windows.begin();
-	     i != _patch_windows.end(); ++i)
+	for (GraphWindowMap::iterator i = _graph_windows.begin();
+	     i != _graph_windows.end(); ++i)
 		delete i->second;
 
-	_patch_windows.clear();
+	_graph_windows.clear();
 }
 
-/** Returns the number of Patch windows currently visible.
+/** Returns the number of Graph windows currently visible.
  */
 size_t
-WindowFactory::num_open_patch_windows()
+WindowFactory::num_open_graph_windows()
 {
 	size_t ret = 0;
-	for (PatchWindowMap::iterator i = _patch_windows.begin();
-	     i != _patch_windows.end(); ++i)
+	for (GraphWindowMap::iterator i = _graph_windows.begin();
+	     i != _graph_windows.end(); ++i)
 		if (i->second->is_visible())
 			++ret;
 
 	return ret;
 }
 
-PatchBox*
-WindowFactory::patch_box(SharedPtr<const PatchModel> patch)
+GraphBox*
+WindowFactory::graph_box(SharedPtr<const GraphModel> graph)
 {
-	PatchWindow* window = patch_window(patch);
+	GraphWindow* window = graph_window(graph);
 	if (window) {
 		return window->box();
 	} else {
@@ -100,87 +100,87 @@ WindowFactory::patch_box(SharedPtr<const PatchModel> patch)
 	}
 }
 
-PatchWindow*
-WindowFactory::patch_window(SharedPtr<const PatchModel> patch)
+GraphWindow*
+WindowFactory::graph_window(SharedPtr<const GraphModel> graph)
 {
-	if (!patch)
+	if (!graph)
 		return NULL;
 
-	PatchWindowMap::iterator w = _patch_windows.find(patch->path());
+	GraphWindowMap::iterator w = _graph_windows.find(graph->path());
 
-	return (w == _patch_windows.end()) ? NULL : w->second;
+	return (w == _graph_windows.end()) ? NULL : w->second;
 }
 
-PatchWindow*
-WindowFactory::parent_patch_window(SharedPtr<const BlockModel> block)
+GraphWindow*
+WindowFactory::parent_graph_window(SharedPtr<const BlockModel> block)
 {
 	if (!block)
 		return NULL;
 
-	return patch_window(PtrCast<PatchModel>(block->parent()));
+	return graph_window(PtrCast<GraphModel>(block->parent()));
 }
 
-/** Present a PatchWindow for a Patch.
+/** Present a GraphWindow for a Graph.
  *
- * If @a preferred is not NULL, it will be set to display @a patch if the patch
+ * If @a preferred is not NULL, it will be set to display @a graph if the graph
  * does not already have a visible window, otherwise that window will be
  * presented and @a preferred left unmodified.
  */
 void
-WindowFactory::present_patch(SharedPtr<const PatchModel> patch,
-                             PatchWindow*                preferred,
-                             SharedPtr<PatchView>        view)
+WindowFactory::present_graph(SharedPtr<const GraphModel> graph,
+                             GraphWindow*                preferred,
+                             SharedPtr<GraphView>        view)
 {
-	assert(!view || view->patch() == patch);
+	assert(!view || view->graph() == graph);
 
-	PatchWindowMap::iterator w = _patch_windows.find(patch->path());
+	GraphWindowMap::iterator w = _graph_windows.find(graph->path());
 
-	if (w != _patch_windows.end()) {
+	if (w != _graph_windows.end()) {
 		(*w).second->present();
 	} else if (preferred) {
-		w = _patch_windows.find(preferred->patch()->path());
+		w = _graph_windows.find(preferred->graph()->path());
 		assert((*w).second == preferred);
 
-		preferred->box()->set_patch(patch, view);
-		_patch_windows.erase(w);
-		_patch_windows[patch->path()] = preferred;
+		preferred->box()->set_graph(graph, view);
+		_graph_windows.erase(w);
+		_graph_windows[graph->path()] = preferred;
 		preferred->present();
 
 	} else {
-		PatchWindow* win = new_patch_window(patch, view);
+		GraphWindow* win = new_graph_window(graph, view);
 		win->present();
 	}
 }
 
-PatchWindow*
-WindowFactory::new_patch_window(SharedPtr<const PatchModel> patch,
-                                SharedPtr<PatchView>        view)
+GraphWindow*
+WindowFactory::new_graph_window(SharedPtr<const GraphModel> graph,
+                                SharedPtr<GraphView>        view)
 {
-	assert(!view || view->patch() == patch);
+	assert(!view || view->graph() == graph);
 
-	PatchWindow* win = NULL;
-	WidgetFactory::get_widget_derived("patch_win", win);
+	GraphWindow* win = NULL;
+	WidgetFactory::get_widget_derived("graph_win", win);
 	win->init_window(_app);
 
-	win->box()->set_patch(patch, view);
-	_patch_windows[patch->path()] = win;
+	win->box()->set_graph(graph, view);
+	_graph_windows[graph->path()] = win;
 
 	win->signal_delete_event().connect(sigc::bind<0>(
-		sigc::mem_fun(this, &WindowFactory::remove_patch_window), win));
+		sigc::mem_fun(this, &WindowFactory::remove_graph_window), win));
 
 	return win;
 }
 
 bool
-WindowFactory::remove_patch_window(PatchWindow* win, GdkEventAny* ignored)
+WindowFactory::remove_graph_window(GraphWindow* win, GdkEventAny* ignored)
 {
-	if (_patch_windows.size() <= 1)
+	if (_graph_windows.size() <= 1)
 		return !_app.quit(win);
 
-	PatchWindowMap::iterator w = _patch_windows.find(win->patch()->path());
+	GraphWindowMap::iterator w = _graph_windows.find(win->graph()->path());
 
 	assert((*w).second == win);
-	_patch_windows.erase(w);
+	_graph_windows.erase(w);
 
 	delete win;
 
@@ -188,12 +188,12 @@ WindowFactory::remove_patch_window(PatchWindow* win, GdkEventAny* ignored)
 }
 
 void
-WindowFactory::present_load_plugin(SharedPtr<const PatchModel> patch,
+WindowFactory::present_load_plugin(SharedPtr<const GraphModel> graph,
                                    GraphObject::Properties     data)
 {
-	PatchWindowMap::iterator w = _patch_windows.find(patch->path());
+	GraphWindowMap::iterator w = _graph_windows.find(graph->path());
 
-	if (w != _patch_windows.end())
+	if (w != _graph_windows.end())
 		_load_plugin_win->set_transient_for(*w->second);
 
 	_load_plugin_win->set_modal(false);
@@ -204,54 +204,54 @@ WindowFactory::present_load_plugin(SharedPtr<const PatchModel> patch,
 		_load_plugin_win->set_default_size(width - width / 8, height / 2);
 	}
 	_load_plugin_win->set_title(
-		string("Load Plugin - ") + patch->path() + " - Ingen");
-	_load_plugin_win->present(patch, data);
+		string("Load Plugin - ") + graph->path() + " - Ingen");
+	_load_plugin_win->present(graph, data);
 }
 
 void
-WindowFactory::present_load_patch(SharedPtr<const PatchModel> patch,
+WindowFactory::present_load_graph(SharedPtr<const GraphModel> graph,
                                   GraphObject::Properties     data)
 {
-	PatchWindowMap::iterator w = _patch_windows.find(patch->path());
+	GraphWindowMap::iterator w = _graph_windows.find(graph->path());
 
-	if (w != _patch_windows.end())
-		_load_patch_win->set_transient_for(*w->second);
+	if (w != _graph_windows.end())
+		_load_graph_win->set_transient_for(*w->second);
 
-	_load_patch_win->present(patch, true, data);
+	_load_graph_win->present(graph, true, data);
 }
 
 void
-WindowFactory::present_load_subpatch(SharedPtr<const PatchModel> patch,
+WindowFactory::present_load_subgraph(SharedPtr<const GraphModel> graph,
                                      GraphObject::Properties     data)
 {
-	PatchWindowMap::iterator w = _patch_windows.find(patch->path());
+	GraphWindowMap::iterator w = _graph_windows.find(graph->path());
 
-	if (w != _patch_windows.end())
-		_load_patch_win->set_transient_for(*w->second);
+	if (w != _graph_windows.end())
+		_load_graph_win->set_transient_for(*w->second);
 
-	_load_patch_win->present(patch, false, data);
+	_load_graph_win->present(graph, false, data);
 }
 
 void
-WindowFactory::present_new_subpatch(SharedPtr<const PatchModel> patch,
+WindowFactory::present_new_subgraph(SharedPtr<const GraphModel> graph,
                                     GraphObject::Properties     data)
 {
-	PatchWindowMap::iterator w = _patch_windows.find(patch->path());
+	GraphWindowMap::iterator w = _graph_windows.find(graph->path());
 
-	if (w != _patch_windows.end())
-		_new_subpatch_win->set_transient_for(*w->second);
+	if (w != _graph_windows.end())
+		_new_subgraph_win->set_transient_for(*w->second);
 
-	_new_subpatch_win->present(patch, data);
+	_new_subgraph_win->present(graph, data);
 }
 
 void
 WindowFactory::present_rename(SharedPtr<const ObjectModel> object)
 {
-	PatchWindowMap::iterator w = _patch_windows.find(object->path());
-	if (w == _patch_windows.end())
-		w = _patch_windows.find(object->path().parent());
+	GraphWindowMap::iterator w = _graph_windows.find(object->path());
+	if (w == _graph_windows.end())
+		w = _graph_windows.find(object->path().parent());
 
-	if (w != _patch_windows.end())
+	if (w != _graph_windows.end())
 		_rename_win->set_transient_for(*w->second);
 
 	_rename_win->present(object);
@@ -260,13 +260,13 @@ WindowFactory::present_rename(SharedPtr<const ObjectModel> object)
 void
 WindowFactory::present_properties(SharedPtr<const ObjectModel> object)
 {
-	PatchWindowMap::iterator w = _patch_windows.find(object->path());
-	if (w == _patch_windows.end())
-		w = _patch_windows.find(object->path().parent());
-	if (w == _patch_windows.end())
-		w = _patch_windows.find(object->path().parent().parent());
+	GraphWindowMap::iterator w = _graph_windows.find(object->path());
+	if (w == _graph_windows.end())
+		w = _graph_windows.find(object->path().parent());
+	if (w == _graph_windows.end())
+		w = _graph_windows.find(object->path().parent().parent());
 
-	if (w != _patch_windows.end())
+	if (w != _graph_windows.end())
 		_properties_win->set_transient_for(*w->second);
 
 	_properties_win->present(object);
diff --git a/src/gui/WindowFactory.hpp b/src/gui/WindowFactory.hpp
index 465bfa80..46c8b39a 100644
--- a/src/gui/WindowFactory.hpp
+++ b/src/gui/WindowFactory.hpp
@@ -27,19 +27,19 @@ namespace Ingen {
 namespace Client {
 class BlockModel;
 class ObjectModel;
-class PatchModel;
+class GraphModel;
 }
 
 namespace GUI {
 
 class App;
-class LoadPatchWindow;
+class GraphBox;
+class GraphView;
+class GraphWindow;
+class LoadGraphWindow;
 class LoadPluginWindow;
-class NewSubpatchWindow;
+class NewSubgraphWindow;
 class PropertiesWindow;
-class PatchBox;
-class PatchView;
-class PatchWindow;
 class RenameWindow;
 
 /** Manager/Factory for all windows.
@@ -53,44 +53,44 @@ public:
 	explicit WindowFactory(App& app);
 	~WindowFactory();
 
-	size_t num_open_patch_windows();
+	size_t num_open_graph_windows();
 
-	PatchBox*    patch_box(SharedPtr<const Client::PatchModel> patch);
-	PatchWindow* patch_window(SharedPtr<const Client::PatchModel> patch);
-	PatchWindow* parent_patch_window(SharedPtr<const Client::BlockModel> block);
+	GraphBox*    graph_box(SharedPtr<const Client::GraphModel> graph);
+	GraphWindow* graph_window(SharedPtr<const Client::GraphModel> graph);
+	GraphWindow* parent_graph_window(SharedPtr<const Client::BlockModel> block);
 
-	void present_patch(
-		SharedPtr<const Client::PatchModel> model,
-		PatchWindow*                        preferred = NULL,
-		SharedPtr<PatchView>                view      = SharedPtr<PatchView>());
+	void present_graph(
+		SharedPtr<const Client::GraphModel> model,
+		GraphWindow*                        preferred = NULL,
+		SharedPtr<GraphView>                view      = SharedPtr<GraphView>());
 
 	typedef GraphObject::Properties Properties;
 
-	void present_load_plugin(SharedPtr<const Client::PatchModel> patch, Properties data=Properties());
-	void present_load_patch(SharedPtr<const Client::PatchModel> patch, Properties data=Properties());
-	void present_load_subpatch(SharedPtr<const Client::PatchModel> patch, Properties data=Properties());
-	void present_new_subpatch(SharedPtr<const Client::PatchModel> patch, Properties data=Properties());
+	void present_load_plugin(SharedPtr<const Client::GraphModel> graph, Properties data=Properties());
+	void present_load_graph(SharedPtr<const Client::GraphModel> graph, Properties data=Properties());
+	void present_load_subgraph(SharedPtr<const Client::GraphModel> graph, Properties data=Properties());
+	void present_new_subgraph(SharedPtr<const Client::GraphModel> graph, Properties data=Properties());
 	void present_rename(SharedPtr<const Client::ObjectModel> object);
 	void present_properties(SharedPtr<const Client::ObjectModel> object);
 
-	bool remove_patch_window(PatchWindow* win, GdkEventAny* ignored = NULL);
+	bool remove_graph_window(GraphWindow* win, GdkEventAny* ignored = NULL);
 
-	void set_main_box(PatchBox* box) { _main_box = box; }
+	void set_main_box(GraphBox* box) { _main_box = box; }
 
 	void clear();
 
 private:
-	typedef std::map<Raul::Path, PatchWindow*> PatchWindowMap;
+	typedef std::map<Raul::Path, GraphWindow*> GraphWindowMap;
 
-	PatchWindow* new_patch_window(SharedPtr<const Client::PatchModel> patch,
-	                              SharedPtr<PatchView>                view);
+	GraphWindow* new_graph_window(SharedPtr<const Client::GraphModel> graph,
+	                              SharedPtr<GraphView>                view);
 
 	App&               _app;
-	PatchBox*          _main_box;
-	PatchWindowMap     _patch_windows;
+	GraphBox*          _main_box;
+	GraphWindowMap     _graph_windows;
 	LoadPluginWindow*  _load_plugin_win;
-	LoadPatchWindow*   _load_patch_win;
-	NewSubpatchWindow* _new_subpatch_win;
+	LoadGraphWindow*   _load_graph_win;
+	NewSubgraphWindow* _new_subgraph_win;
 	PropertiesWindow*  _properties_win;
 	RenameWindow*      _rename_win;
 };
diff --git a/src/gui/ingen_gui.ui b/src/gui/ingen_gui.ui
index ed393082..3f939608 100644
--- a/src/gui/ingen_gui.ui
+++ b/src/gui/ingen_gui.ui
@@ -168,25 +168,25 @@ Contributors:
       </object>
     </child>
     <child>
-      <object class="GtkImageMenuItem" id="canvas_menu_load_patch">
-        <property name="label">_Load Patch...</property>
+      <object class="GtkImageMenuItem" id="canvas_menu_load_graph">
+        <property name="label">_Load Graph...</property>
         <property name="visible">True</property>
         <property name="can_focus">False</property>
         <property name="use_action_appearance">False</property>
         <property name="use_underline">True</property>
         <property name="use_stock">False</property>
-        <signal name="activate" handler="on_canvas_menu_load_patch_activate" swapped="no"/>
+        <signal name="activate" handler="on_canvas_menu_load_graph_activate" swapped="no"/>
       </object>
     </child>
     <child>
-      <object class="GtkImageMenuItem" id="canvas_menu_new_patch">
-        <property name="label">_New Patch...</property>
+      <object class="GtkImageMenuItem" id="canvas_menu_new_graph">
+        <property name="label">_New Graph...</property>
         <property name="visible">True</property>
         <property name="can_focus">False</property>
         <property name="use_action_appearance">False</property>
         <property name="use_underline">True</property>
         <property name="use_stock">False</property>
-        <signal name="activate" handler="on_canvas_menu_new_patch_activate" swapped="no"/>
+        <signal name="activate" handler="on_canvas_menu_new_graph_activate" swapped="no"/>
       </object>
     </child>
   </object>
@@ -209,7 +209,7 @@ Contributors:
               <object class="GtkLabel" id="label90">
                 <property name="visible">True</property>
                 <property name="can_focus">False</property>
-                <property name="label" translatable="yes">&lt;b&gt;Patch Search Path: &lt;/b&gt;</property>
+                <property name="label" translatable="yes">&lt;b&gt;Graph Search Path: &lt;/b&gt;</property>
                 <property name="use_markup">True</property>
               </object>
               <packing>
@@ -232,7 +232,7 @@ Contributors:
               <object class="GtkLabel" id="label91">
                 <property name="visible">True</property>
                 <property name="can_focus">False</property>
-                <property name="label" translatable="yes">&lt;i&gt;Example:  /foo/bar:/home/john/patches:/usr/share/om/patches&lt;/i&gt;</property>
+                <property name="label" translatable="yes">&lt;i&gt;Example:  /foo/bar:/home/user/graphs&lt;/i&gt;</property>
                 <property name="use_markup">True</property>
               </object>
               <packing>
@@ -684,9 +684,9 @@ Contributors:
       <action-widget response="-6">connect_connect_button</action-widget>
     </action-widgets>
   </object>
-  <object class="GtkFileChooserDialog" id="load_patch_win">
+  <object class="GtkFileChooserDialog" id="load_graph_win">
     <property name="can_focus">False</property>
-    <property name="title" translatable="yes">Load Patch - Ingen</property>
+    <property name="title" translatable="yes">Load Graph - Ingen</property>
     <property name="window_position">center-on-parent</property>
     <property name="type_hint">dialog</property>
     <child internal-child="vbox">
@@ -699,7 +699,7 @@ Contributors:
             <property name="can_focus">False</property>
             <property name="layout_style">end</property>
             <child>
-              <object class="GtkButton" id="load_patch_cancel_button">
+              <object class="GtkButton" id="load_graph_cancel_button">
                 <property name="label">gtk-cancel</property>
                 <property name="visible">True</property>
                 <property name="can_focus">True</property>
@@ -715,7 +715,7 @@ Contributors:
               </packing>
             </child>
             <child>
-              <object class="GtkButton" id="load_patch_ok_button">
+              <object class="GtkButton" id="load_graph_ok_button">
                 <property name="label">gtk-open</property>
                 <property name="visible">True</property>
                 <property name="can_focus">True</property>
@@ -754,7 +754,7 @@ Contributors:
                 <property name="column_spacing">12</property>
                 <property name="row_spacing">12</property>
                 <child>
-                  <object class="GtkLabel" id="load_patch_poly_label">
+                  <object class="GtkLabel" id="load_graph_poly_label">
                     <property name="visible">True</property>
                     <property name="can_focus">False</property>
                     <property name="xalign">0</property>
@@ -769,7 +769,7 @@ Contributors:
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkRadioButton" id="load_patch_poly_from_file_radio">
+                  <object class="GtkRadioButton" id="load_graph_poly_from_file_radio">
                     <property name="label" translatable="yes">Load from _File</property>
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
@@ -778,7 +778,7 @@ Contributors:
                     <property name="use_action_appearance">False</property>
                     <property name="use_underline">True</property>
                     <property name="draw_indicator">True</property>
-                    <property name="group">load_patch_poly_voices_radio</property>
+                    <property name="group">load_graph_poly_voices_radio</property>
                   </object>
                   <packing>
                     <property name="left_attach">2</property>
@@ -790,7 +790,7 @@ Contributors:
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkLabel" id="load_patch_ports_label">
+                  <object class="GtkLabel" id="load_graph_ports_label">
                     <property name="visible">True</property>
                     <property name="can_focus">False</property>
                     <property name="xalign">0</property>
@@ -804,7 +804,7 @@ Contributors:
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkRadioButton" id="load_patch_insert_ports_radio">
+                  <object class="GtkRadioButton" id="load_graph_insert_ports_radio">
                     <property name="label" translatable="yes">_Insert new ports</property>
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
@@ -813,7 +813,7 @@ Contributors:
                     <property name="use_action_appearance">False</property>
                     <property name="use_underline">True</property>
                     <property name="draw_indicator">True</property>
-                    <property name="group">load_patch_merge_ports_radio</property>
+                    <property name="group">load_graph_merge_ports_radio</property>
                   </object>
                   <packing>
                     <property name="left_attach">2</property>
@@ -824,7 +824,7 @@ Contributors:
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkRadioButton" id="load_patch_merge_ports_radio">
+                  <object class="GtkRadioButton" id="load_graph_merge_ports_radio">
                     <property name="label" translatable="yes">_Merge with existing ports</property>
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
@@ -849,7 +849,7 @@ Contributors:
                     <property name="can_focus">False</property>
                     <property name="spacing">6</property>
                     <child>
-                      <object class="GtkRadioButton" id="load_patch_poly_voices_radio">
+                      <object class="GtkRadioButton" id="load_graph_poly_voices_radio">
                         <property name="label" translatable="yes">_Voices:</property>
                         <property name="visible">True</property>
                         <property name="can_focus">True</property>
@@ -867,7 +867,7 @@ Contributors:
                       </packing>
                     </child>
                     <child>
-                      <object class="GtkSpinButton" id="load_patch_poly_spinbutton">
+                      <object class="GtkSpinButton" id="load_graph_poly_spinbutton">
                         <property name="visible">True</property>
                         <property name="can_focus">True</property>
                         <property name="invisible_char">●</property>
@@ -890,14 +890,14 @@ Contributors:
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkLabel" id="load_patch_symbol_label">
+                  <object class="GtkLabel" id="load_graph_symbol_label">
                     <property name="visible">True</property>
                     <property name="can_focus">False</property>
                     <property name="xalign">0</property>
                     <property name="label" translatable="yes">_Symbol: </property>
                     <property name="use_markup">True</property>
                     <property name="use_underline">True</property>
-                    <property name="mnemonic_widget">load_patch_symbol_entry</property>
+                    <property name="mnemonic_widget">load_graph_symbol_entry</property>
                   </object>
                   <packing>
                     <property name="x_options">GTK_FILL</property>
@@ -905,7 +905,7 @@ Contributors:
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkEntry" id="load_patch_symbol_entry">
+                  <object class="GtkEntry" id="load_graph_symbol_entry">
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
                     <property name="invisible_char">●</property>
@@ -929,8 +929,8 @@ Contributors:
       </object>
     </child>
     <action-widgets>
-      <action-widget response="-6">load_patch_cancel_button</action-widget>
-      <action-widget response="-5">load_patch_ok_button</action-widget>
+      <action-widget response="-6">load_graph_cancel_button</action-widget>
+      <action-widget response="-5">load_graph_ok_button</action-widget>
     </action-widgets>
   </object>
   <object class="GtkWindow" id="load_plugin_win">
@@ -1236,11 +1236,11 @@ Contributors:
       </object>
     </child>
   </object>
-  <object class="GtkWindow" id="new_subpatch_win">
+  <object class="GtkWindow" id="new_subgraph_win">
     <property name="width_request">320</property>
     <property name="can_focus">False</property>
     <property name="border_width">8</property>
-    <property name="title" translatable="yes">Create Subpatch - Ingen</property>
+    <property name="title" translatable="yes">Create Subgraph - Ingen</property>
     <property name="resizable">False</property>
     <property name="window_position">center-on-parent</property>
     <property name="type_hint">dialog</property>
@@ -1261,7 +1261,7 @@ Contributors:
                 <property name="xalign">0</property>
                 <property name="label" translatable="yes">_Symbol: </property>
                 <property name="use_underline">True</property>
-                <property name="mnemonic_widget">new_subpatch_name_entry</property>
+                <property name="mnemonic_widget">new_subgraph_name_entry</property>
               </object>
               <packing>
                 <property name="x_options">GTK_FILL</property>
@@ -1276,7 +1276,7 @@ Contributors:
                 <property name="xalign">0</property>
                 <property name="label" translatable="yes">_Polyphony: </property>
                 <property name="use_underline">True</property>
-                <property name="mnemonic_widget">new_subpatch_polyphony_spinbutton</property>
+                <property name="mnemonic_widget">new_subgraph_polyphony_spinbutton</property>
               </object>
               <packing>
                 <property name="top_attach">1</property>
@@ -1287,7 +1287,7 @@ Contributors:
               </packing>
             </child>
             <child>
-              <object class="GtkSpinButton" id="new_subpatch_polyphony_spinbutton">
+              <object class="GtkSpinButton" id="new_subgraph_polyphony_spinbutton">
                 <property name="visible">True</property>
                 <property name="can_focus">True</property>
                 <property name="invisible_char">●</property>
@@ -1305,7 +1305,7 @@ Contributors:
               </packing>
             </child>
             <child>
-              <object class="GtkEntry" id="new_subpatch_name_entry">
+              <object class="GtkEntry" id="new_subgraph_name_entry">
                 <property name="visible">True</property>
                 <property name="can_focus">True</property>
                 <property name="invisible_char">●</property>
@@ -1326,7 +1326,7 @@ Contributors:
           </packing>
         </child>
         <child>
-          <object class="GtkLabel" id="new_subpatch_message_label">
+          <object class="GtkLabel" id="new_subgraph_message_label">
             <property name="visible">True</property>
             <property name="can_focus">False</property>
             <property name="wrap">True</property>
@@ -1344,7 +1344,7 @@ Contributors:
             <property name="spacing">4</property>
             <property name="layout_style">end</property>
             <child>
-              <object class="GtkButton" id="new_subpatch_cancel_button">
+              <object class="GtkButton" id="new_subgraph_cancel_button">
                 <property name="label">gtk-cancel</property>
                 <property name="visible">True</property>
                 <property name="can_focus">True</property>
@@ -1359,7 +1359,7 @@ Contributors:
               </packing>
             </child>
             <child>
-              <object class="GtkButton" id="new_subpatch_ok_button">
+              <object class="GtkButton" id="new_subgraph_ok_button">
                 <property name="label">gtk-ok</property>
                 <property name="visible">True</property>
                 <property name="can_focus">True</property>
@@ -1516,12 +1516,12 @@ Contributors:
       </object>
     </child>
   </object>
-  <object class="GtkWindow" id="patch_tree_win">
+  <object class="GtkWindow" id="graph_tree_win">
     <property name="width_request">320</property>
     <property name="height_request">340</property>
     <property name="can_focus">False</property>
     <property name="border_width">8</property>
-    <property name="title" translatable="yes">Patches - Ingen</property>
+    <property name="title" translatable="yes">Graphs - Ingen</property>
     <child>
       <object class="GtkScrolledWindow" id="scrolledwindow8">
         <property name="visible">True</property>
@@ -1529,7 +1529,7 @@ Contributors:
         <property name="border_width">3</property>
         <property name="shadow_type">in</property>
         <child>
-          <object class="GtkTreeView" id="patches_treeview">
+          <object class="GtkTreeView" id="graphs_treeview">
             <property name="visible">True</property>
             <property name="can_focus">True</property>
             <property name="rules_hint">True</property>
@@ -1538,13 +1538,13 @@ Contributors:
       </object>
     </child>
   </object>
-  <object class="GtkWindow" id="patch_win">
+  <object class="GtkWindow" id="graph_win">
     <property name="can_focus">False</property>
     <property name="title" translatable="yes">Ingen</property>
     <property name="default_width">776</property>
     <property name="default_height">480</property>
     <child>
-      <object class="GtkVBox" id="patch_win_vbox">
+      <object class="GtkVBox" id="graph_win_vbox">
         <property name="visible">True</property>
         <property name="can_focus">False</property>
         <child>
@@ -1552,17 +1552,17 @@ Contributors:
             <property name="visible">True</property>
             <property name="can_focus">False</property>
             <child>
-              <object class="GtkMenuItem" id="patch_file_menu">
+              <object class="GtkMenuItem" id="graph_file_menu">
                 <property name="visible">True</property>
                 <property name="can_focus">False</property>
                 <property name="use_action_appearance">False</property>
                 <property name="label" translatable="yes">_File</property>
                 <property name="use_underline">True</property>
                 <child type="submenu">
-                  <object class="GtkMenu" id="patch_file_menu_menu">
+                  <object class="GtkMenu" id="graph_file_menu_menu">
                     <property name="can_focus">False</property>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_import_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_import_menuitem">
                         <property name="label">_Import...</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1570,7 +1570,7 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">False</property>
                         <accelerator key="I" signal="activate" modifiers="GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_patch_import_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_import_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
@@ -1580,7 +1580,7 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_save_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_save_menuitem">
                         <property name="label">gtk-save</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1588,11 +1588,11 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">True</property>
                         <accelerator key="S" signal="activate" modifiers="GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_file_save_patch_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_file_save_graph_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_save_as_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_save_as_menuitem">
                         <property name="label">Save _As...</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1600,11 +1600,11 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">False</property>
                         <accelerator key="S" signal="activate" modifiers="GDK_SHIFT_MASK | GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_patch_save_as_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_save_as_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_draw_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_draw_menuitem">
                         <property name="label">_Draw...</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1612,7 +1612,7 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">False</property>
                         <accelerator key="D" signal="activate" modifiers="GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_patch_draw_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_draw_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
@@ -1622,14 +1622,14 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_close_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_close_menuitem">
                         <property name="label">gtk-close</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
                         <property name="use_underline">True</property>
                         <property name="use_stock">True</property>
-                        <signal name="activate" handler="on_patch_file_close_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_file_close_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
@@ -1639,14 +1639,14 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_quit_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_quit_menuitem">
                         <property name="label">gtk-quit</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
                         <property name="use_underline">True</property>
                         <property name="use_stock">True</property>
-                        <signal name="activate" handler="on_patch_file_quit_nokill_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_file_quit_nokill_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                   </object>
@@ -1670,7 +1670,7 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_cut_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_cut_menuitem">
                         <property name="label">gtk-cut</property>
                         <property name="visible">True</property>
                         <property name="sensitive">False</property>
@@ -1678,11 +1678,11 @@ Contributors:
                         <property name="use_action_appearance">False</property>
                         <property name="use_underline">True</property>
                         <property name="use_stock">True</property>
-                        <signal name="activate" handler="on_patch_cut_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_cut_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_copy_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_copy_menuitem">
                         <property name="label">gtk-copy</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1690,11 +1690,11 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">True</property>
                         <accelerator key="C" signal="activate" modifiers="GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_patch_copy_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_copy_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_paste_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_paste_menuitem">
                         <property name="label">gtk-paste</property>
                         <property name="visible">True</property>
                         <property name="sensitive">False</property>
@@ -1703,11 +1703,11 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">True</property>
                         <accelerator key="V" signal="activate" modifiers="GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_patch_paste_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_paste_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_delete_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_delete_menuitem">
                         <property name="label">gtk-delete</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1715,11 +1715,11 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">True</property>
                         <accelerator key="Delete" signal="activate"/>
-                        <signal name="activate" handler="on_patch_delete_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_delete_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_select_all_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_select_all_menuitem">
                         <property name="label">gtk-select-all</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1727,7 +1727,7 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">True</property>
                         <accelerator key="A" signal="activate" modifiers="GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_patch_select_all_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_select_all_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
@@ -1737,7 +1737,7 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_arrange_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_arrange_menuitem">
                         <property name="label">Arrange</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1754,7 +1754,7 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_view_control_window_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_view_control_window_menuitem">
                         <property name="label">C_ontrols...</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1762,11 +1762,11 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">False</property>
                         <accelerator key="O" signal="activate" modifiers="GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_patch_view_control_window_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_view_control_window_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_properties_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_properties_menuitem">
                         <property name="label">gtk-properties</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1774,7 +1774,7 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">True</property>
                         <accelerator key="P" signal="activate" modifiers="GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_patch_properties_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_properties_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                   </object>
@@ -1782,17 +1782,17 @@ Contributors:
               </object>
             </child>
             <child>
-              <object class="GtkMenuItem" id="patch_patch_menu">
+              <object class="GtkMenuItem" id="graph_graph_menu">
                 <property name="visible">True</property>
                 <property name="can_focus">False</property>
                 <property name="use_action_appearance">False</property>
                 <property name="label" translatable="yes">_View</property>
                 <property name="use_underline">True</property>
                 <child type="submenu">
-                  <object class="GtkMenu" id="patch_patch_menu_menu">
+                  <object class="GtkMenu" id="graph_graph_menu_menu">
                     <property name="can_focus">False</property>
                     <child>
-                      <object class="GtkCheckMenuItem" id="patch_human_names_menuitem">
+                      <object class="GtkCheckMenuItem" id="graph_human_names_menuitem">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
@@ -1803,7 +1803,7 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkCheckMenuItem" id="patch_show_port_names_menuitem">
+                      <object class="GtkCheckMenuItem" id="graph_show_port_names_menuitem">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
@@ -1814,7 +1814,7 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkCheckMenuItem" id="patch_status_bar_menuitem">
+                      <object class="GtkCheckMenuItem" id="graph_status_bar_menuitem">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
@@ -1831,7 +1831,7 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_zoom_in_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_zoom_in_menuitem">
                         <property name="label">gtk-zoom-in</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1842,7 +1842,7 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_zoom_out_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_zoom_out_menuitem">
                         <property name="label">gtk-zoom-out</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1853,7 +1853,7 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_zoom_normal_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_zoom_normal_menuitem">
                         <property name="label">gtk-zoom-100</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1870,7 +1870,7 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_fullscreen_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_fullscreen_menuitem">
                         <property name="label">gtk-fullscreen</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1878,7 +1878,7 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">True</property>
                         <accelerator key="F11" signal="activate"/>
-                        <signal name="activate" handler="patch_fullscreen_menuitem" swapped="no"/>
+                        <signal name="activate" handler="graph_fullscreen_menuitem" swapped="no"/>
                       </object>
                     </child>
                   </object>
@@ -1897,7 +1897,7 @@ Contributors:
                   <object class="GtkMenu" id="view1_menu">
                     <property name="can_focus">False</property>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_view_engine_window_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_view_engine_window_menuitem">
                         <property name="label">_Engine</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1905,23 +1905,23 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">False</property>
                         <accelerator key="E" signal="activate" modifiers="GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_patch_view_engine_window_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_view_engine_window_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_view_patch_tree_window_menuitem">
-                        <property name="label">_Patch Tree</property>
+                      <object class="GtkImageMenuItem" id="graph_view_graph_tree_window_menuitem">
+                        <property name="label">_Graph Tree</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
                         <property name="use_underline">True</property>
                         <property name="use_stock">False</property>
                         <accelerator key="T" signal="activate" modifiers="GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_patch_view_tree_window_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_view_tree_window_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_view_messages_window_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_view_messages_window_menuitem">
                         <property name="label">_Messages</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1929,7 +1929,7 @@ Contributors:
                         <property name="use_underline">True</property>
                         <property name="use_stock">False</property>
                         <accelerator key="M" signal="activate" modifiers="GDK_CONTROL_MASK"/>
-                        <signal name="activate" handler="on_patch_view_messages_window_menuitem_activate" swapped="no"/>
+                        <signal name="activate" handler="on_graph_view_messages_window_menuitem_activate" swapped="no"/>
                       </object>
                     </child>
                   </object>
@@ -1964,7 +1964,7 @@ Contributors:
                       </object>
                     </child>
                     <child>
-                      <object class="GtkImageMenuItem" id="patch_help_about_menuitem">
+                      <object class="GtkImageMenuItem" id="graph_help_about_menuitem">
                         <property name="label">gtk-about</property>
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
@@ -1986,11 +1986,11 @@ Contributors:
           </packing>
         </child>
         <child>
-          <object class="GtkHPaned" id="patch_documentation_paned">
+          <object class="GtkHPaned" id="graph_documentation_paned">
             <property name="visible">True</property>
             <property name="can_focus">False</property>
             <child>
-              <object class="GtkAlignment" id="patch_win_alignment">
+              <object class="GtkAlignment" id="graph_win_alignment">
                 <property name="visible">True</property>
                 <property name="can_focus">False</property>
                 <child>
@@ -2003,7 +2003,7 @@ Contributors:
               </packing>
             </child>
             <child>
-              <object class="GtkScrolledWindow" id="patch_documentation_scrolledwindow">
+              <object class="GtkScrolledWindow" id="graph_documentation_scrolledwindow">
                 <property name="can_focus">False</property>
                 <property name="shadow_type">in</property>
                 <child>
@@ -2023,7 +2023,7 @@ Contributors:
           </packing>
         </child>
         <child>
-          <object class="GtkStatusbar" id="patch_win_status_bar">
+          <object class="GtkStatusbar" id="graph_win_status_bar">
             <property name="visible">True</property>
             <property name="can_focus">False</property>
             <property name="spacing">2</property>
@@ -2610,7 +2610,7 @@ Contributors:
           </object>
         </child>
         <child>
-          <object class="GtkVBox" id="patch_view_box">
+          <object class="GtkVBox" id="graph_view_box">
             <property name="visible">True</property>
             <property name="can_focus">False</property>
             <child>
@@ -2624,7 +2624,7 @@ Contributors:
                     <property name="toolbar_style">icons</property>
                     <property name="icon_size">1</property>
                     <child>
-                      <object class="GtkToolItem" id="patch_view_breadcrumb_container">
+                      <object class="GtkToolItem" id="graph_view_breadcrumb_container">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
@@ -2644,14 +2644,14 @@ Contributors:
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkToolbar" id="patch_view_toolbar">
+                  <object class="GtkToolbar" id="graph_view_toolbar">
                     <property name="visible">True</property>
                     <property name="can_focus">False</property>
                     <property name="toolbar_style">icons</property>
                     <property name="show_arrow">False</property>
                     <property name="icon_size">1</property>
                     <child>
-                      <object class="GtkToggleToolButton" id="patch_view_process_but">
+                      <object class="GtkToggleToolButton" id="graph_view_process_but">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
@@ -2688,7 +2688,7 @@ Contributors:
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
                         <child>
-                          <object class="GtkSpinButton" id="patch_view_poly_spin">
+                          <object class="GtkSpinButton" id="graph_view_poly_spin">
                             <property name="visible">True</property>
                             <property name="can_focus">True</property>
                             <property name="climb_rate">1</property>
@@ -2710,7 +2710,7 @@ Contributors:
                       </packing>
                     </child>
                     <child>
-                      <object class="GtkToolButton" id="patch_view_save_but">
+                      <object class="GtkToolButton" id="graph_view_save_but">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
@@ -2731,7 +2731,7 @@ Contributors:
                       </packing>
                     </child>
                     <child>
-                      <object class="GtkToolButton" id="patch_view_refresh_but">
+                      <object class="GtkToolButton" id="graph_view_refresh_but">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
@@ -2743,7 +2743,7 @@ Contributors:
                       </packing>
                     </child>
                     <child>
-                      <object class="GtkToolButton" id="patch_view_zoom_normal_but">
+                      <object class="GtkToolButton" id="graph_view_zoom_normal_but">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
@@ -2756,7 +2756,7 @@ Contributors:
                       </packing>
                     </child>
                     <child>
-                      <object class="GtkToolButton" id="patch_view_zoom_full_but">
+                      <object class="GtkToolButton" id="graph_view_zoom_full_but">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <property name="use_action_appearance">False</property>
@@ -2783,7 +2783,7 @@ Contributors:
               </packing>
             </child>
             <child>
-              <object class="GtkScrolledWindow" id="patch_view_scrolledwindow">
+              <object class="GtkScrolledWindow" id="graph_view_scrolledwindow">
                 <property name="visible">True</property>
                 <property name="can_default">True</property>
                 <property name="has_default">True</property>
diff --git a/src/gui/ingen_gui_lv2.cpp b/src/gui/ingen_gui_lv2.cpp
index 937ecd38..d66405fb 100644
--- a/src/gui/ingen_gui_lv2.cpp
+++ b/src/gui/ingen_gui_lv2.cpp
@@ -19,15 +19,15 @@
 #include "ingen/AtomWriter.hpp"
 #include "ingen/World.hpp"
 #include "ingen/client/ClientStore.hpp"
-#include "ingen/client/PatchModel.hpp"
+#include "ingen/client/GraphModel.hpp"
 #include "ingen/client/SigClientInterface.hpp"
 #include "ingen/runtime_paths.hpp"
 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
 
 #include "App.hpp"
-#include "PatchBox.hpp"
+#include "GraphBox.hpp"
 
-#define INGEN_LV2_UI_URI "http://drobilla.net/ns/ingen#PatchUIGtk2"
+#define INGEN_LV2_UI_URI "http://drobilla.net/ns/ingen#GraphUIGtk2"
 
 /** A sink that writes atoms to a port via the UI extension. */
 struct IngenLV2AtomSink : public Ingen::AtomSink {
@@ -68,7 +68,7 @@ struct IngenLV2UI {
 	Ingen::World*                                world;
 	IngenLV2AtomSink*                            sink;
 	SharedPtr<Ingen::GUI::App>                   app;
-	SharedPtr<Ingen::GUI::PatchBox>              view;
+	SharedPtr<Ingen::GUI::GraphBox>              view;
 	SharedPtr<Ingen::Interface>                  engine;
 	SharedPtr<Ingen::AtomReader>                 reader;
 	SharedPtr<Ingen::Client::SigClientInterface> client;
@@ -135,20 +135,20 @@ instantiate(const LV2UI_Descriptor*   descriptor,
 	// Request plugins
 	ui->world->interface()->get(Raul::URI("ingen:plugins"));
 
-	// Create empty root patch model
+	// Create empty root graph model
 	Ingen::Resource::Properties props;
 	props.insert(std::make_pair(ui->app->uris().rdf_type,
-	                            ui->app->uris().ingen_Patch));
+	                            ui->app->uris().ingen_Graph));
 	ui->app->store()->put(Ingen::GraphObject::root_uri(), props);
 
-	// Create a PatchBox for the root and set as the UI widget
-	SharedPtr<const Ingen::Client::PatchModel> root = PtrCast<const Ingen::Client::PatchModel>(
+	// Create a GraphBox for the root and set as the UI widget
+	SharedPtr<const Ingen::Client::GraphModel> root = PtrCast<const Ingen::Client::GraphModel>(
 		ui->app->store()->object(Raul::Path("/")));
-	ui->view = Ingen::GUI::PatchBox::create(*ui->app, root);
+	ui->view = Ingen::GUI::GraphBox::create(*ui->app, root);
 	ui->view->unparent();
 	*widget = ui->view->gobj();
 
-	// Request the actual root patch
+	// Request the actual root graph
 	ui->world->interface()->get(Ingen::GraphObject::root_uri());
 
 	return ui;
diff --git a/src/gui/wscript b/src/gui/wscript
index 7702bd4f..7d022b27 100644
--- a/src/gui/wscript
+++ b/src/gui/wscript
@@ -32,25 +32,25 @@ def build(bld):
             Configuration.cpp
             ConnectWindow.cpp
             Edge.cpp
-            LoadPatchWindow.cpp
+            GraphBox.cpp
+            GraphCanvas.cpp
+            GraphPortModule.cpp
+            GraphTreeWindow.cpp
+            GraphView.cpp
+            GraphWindow.cpp
+            LoadGraphWindow.cpp
             LoadPluginWindow.cpp
             MessagesWindow.cpp
-            NewSubpatchWindow.cpp
+            NewSubgraphWindow.cpp
             NodeMenu.cpp
             NodeModule.cpp
             ObjectMenu.cpp
-            PatchBox.cpp
-            PatchCanvas.cpp
-            PatchPortModule.cpp
-            PatchTreeWindow.cpp
-            PatchView.cpp
-            PatchWindow.cpp
             Port.cpp
             PortMenu.cpp
             PortPropertiesWindow.cpp
             PropertiesWindow.cpp
             RenameWindow.cpp
-            SubpatchModule.cpp
+            SubgraphModule.cpp
             ThreadedLoader.cpp
             WidgetFactory.cpp
             Window.cpp
diff --git a/src/ingen/main.cpp b/src/ingen/main.cpp
index 44f042a4..a0b0dbbe 100644
--- a/src/ingen/main.cpp
+++ b/src/ingen/main.cpp
@@ -151,7 +151,7 @@ main(int argc, char** argv)
 		world->engine()->activate();
 	}
 
-	// Load a patch
+	// Load a graph
 	if (conf.option("load").is_valid() || !conf.files().empty()) {
 		boost::optional<Raul::Path>   parent;
 		boost::optional<Raul::Symbol> symbol;
diff --git a/src/serialisation/Parser.cpp b/src/serialisation/Parser.cpp
index 900aba02..9a5c52ed 100644
--- a/src/serialisation/Parser.cpp
+++ b/src/serialisation/Parser.cpp
@@ -179,7 +179,7 @@ parse(
 	boost::optional<Resource::Properties> data   = boost::optional<Resource::Properties>());
 
 static boost::optional<Raul::Path>
-parse_patch(
+parse_graph(
 	World*                                world,
 	Interface*                            target,
 	Sord::Model&                          model,
@@ -212,7 +212,7 @@ parse_edges(
 		Interface*        target,
 		Sord::Model&      model,
 		const Sord::Node& subject,
-		const Raul::Path& patch);
+		const Raul::Path& graph);
 
 static boost::optional<Raul::Path>
 parse_block(Ingen::World*                            world,
@@ -263,10 +263,10 @@ parse_block(Ingen::World*                            world,
 		serd_env_free(env);
 
 		Sord::URI sub_node(*world->rdf_world(), sub_file);
-		parse_patch(world, target, sub_model, sub_node,
+		parse_graph(world, target, sub_model, sub_node,
 		            path.parent(), Raul::Symbol(path.symbol()));
 
-		parse_patch(world, target, model, subject,
+		parse_graph(world, target, model, subject,
 		            path.parent(), Raul::Symbol(path.symbol()));
 	} else {
 		Resource::Properties props = get_properties(world, model, subject);
@@ -278,7 +278,7 @@ parse_block(Ingen::World*                            world,
 }
 
 static boost::optional<Raul::Path>
-parse_patch(Ingen::World*                            world,
+parse_graph(Ingen::World*                            world,
             Ingen::Interface*                        target,
             Sord::Model&                             model,
             const Sord::Node&                        subject_node,
@@ -292,7 +292,7 @@ parse_patch(Ingen::World*                            world,
 	const Sord::URI ingen_polyphony(*world->rdf_world(), uris.ingen_polyphony);
 	const Sord::URI lv2_port(*world->rdf_world(),        LV2_CORE__port);
 
-	const Sord::Node& patch = subject_node;
+	const Sord::Node& graph = subject_node;
 	const Sord::Node  nil;
 
 	const Glib::ustring base_uri = model.base_uri().to_string();
@@ -304,25 +304,25 @@ parse_patch(Ingen::World*                            world,
 		const std::string basename = get_basename(base_uri);
 	}
 
-	string patch_path_str = relative_uri(base_uri, subject_node.to_string(), true);
+	string graph_path_str = relative_uri(base_uri, subject_node.to_string(), true);
 	if (parent && a_symbol)
-		patch_path_str = parent->child(*a_symbol);
+		graph_path_str = parent->child(*a_symbol);
 
-	if (!Raul::Path::is_valid(patch_path_str)) {
-		world->log().error(Raul::fmt("Patch %1% has invalid path\n")
-		                   %  patch_path_str);
+	if (!Raul::Path::is_valid(graph_path_str)) {
+		world->log().error(Raul::fmt("Graph %1% has invalid path\n")
+		                   %  graph_path_str);
 		return boost::optional<Raul::Path>();
 	}
 
-	// Create patch
-	Raul::Path patch_path(patch_path_str);
+	// Create graph
+	Raul::Path graph_path(graph_path_str);
 	Resource::Properties props = get_properties(world, model, subject_node);
-	target->put(GraphObject::path_to_uri(patch_path), props);
+	target->put(GraphObject::path_to_uri(graph_path), props);
 
-	// For each block in this patch
+	// For each block in this graph
 	for (Sord::Iter n = model.find(subject_node, ingen_block, nil); !n.end(); ++n) {
 		Sord::Node       node       = n.get_object();
-		const Raul::Path block_path = patch_path.child(
+		const Raul::Path block_path = graph_path.child(
 			Raul::Symbol(get_basename(node.to_string())));
 
 		// Parse and create block
@@ -348,16 +348,16 @@ parse_patch(Ingen::World*                            world,
 		}
 	}
 
-	// For each port on this patch
+	// For each port on this graph
 	typedef std::map<uint32_t, PortRecord> PortRecords;
 	PortRecords ports;
-	for (Sord::Iter p = model.find(patch, lv2_port, nil); !p.end(); ++p) {
+	for (Sord::Iter p = model.find(graph, lv2_port, nil); !p.end(); ++p) {
 		Sord::Node port = p.get_object();
 
 		// Get all properties
 		uint32_t index = 0;
 		boost::optional<PortRecord> port_record = get_port(
-			world, model, port, patch_path, index);
+			world, model, port, graph_path, index);
 		if (!port_record) {
 			world->log().error(Raul::fmt("Invalid port %1%\n") % port);
 			return boost::optional<Raul::Path>();
@@ -373,9 +373,9 @@ parse_patch(Ingen::World*                            world,
 		            i->second.second);
 	}
 
-	parse_edges(world, target, model, subject_node, patch_path);
+	parse_edges(world, target, model, subject_node, graph_path);
 
-	return patch_path;
+	return graph_path;
 }
 
 static bool
@@ -479,7 +479,7 @@ parse(Ingen::World*                            world,
 {
 	URIs& uris = world->uris();
 
-	const Sord::URI  patch_class   (*world->rdf_world(), uris.ingen_Patch);
+	const Sord::URI  graph_class   (*world->rdf_world(), uris.ingen_Graph);
 	const Sord::URI  block_class   (*world->rdf_world(), uris.ingen_Block);
 	const Sord::URI  edge_class    (*world->rdf_world(), uris.ingen_Edge);
 	const Sord::URI  internal_class(*world->rdf_world(), uris.ingen_Internal);
@@ -489,9 +489,9 @@ parse(Ingen::World*                            world,
 	const Sord::URI  rdf_type      (*world->rdf_world(), uris.rdf_type);
 	const Sord::Node nil;
 
-	// Parse explicit subject patch
+	// Parse explicit subject graph
 	if (subject.is_valid()) {
-		return parse_patch(world, target, model, subject, parent, symbol, data);
+		return parse_graph(world, target, model, subject, parent, symbol, data);
 	}
 
 	// Get all subjects and their types (?subject a ?type)
@@ -519,8 +519,8 @@ parse(Ingen::World*                            world,
 		boost::optional<Raul::Path> ret;
 		const Raul::Path path(
 			relative_uri( model.base_uri().to_string(), s.to_string(), true));
-		if (types.find(patch_class) != types.end()) {
-			ret = parse_patch(world, target, model, s, parent, symbol, data);
+		if (types.find(graph_class) != types.end()) {
+			ret = parse_graph(world, target, model, s, parent, symbol, data);
 		} else if (types.find(block_class) != types.end()) {
 			ret = parse_block(world, target, model, s, path, data);
 		} else if (types.find(in_port_class) != types.end() ||
@@ -539,7 +539,7 @@ parse(Ingen::World*                            world,
 	return boost::optional<Raul::Path>();
 }
 
-/** Parse a patch from RDF into a Interface (engine or client).
+/** Parse a graph from RDF into a Interface (engine or client).
  * @return whether or not load was successful.
  */
 bool
@@ -551,7 +551,7 @@ Parser::parse_file(Ingen::World*                            world,
                    boost::optional<GraphObject::Properties> data)
 {
 	if (Glib::file_test(path, Glib::FILE_TEST_IS_DIR)) {
-		// This is a bundle, append "/name.ttl" to get patch file path
+		// This is a bundle, append "/name.ttl" to get graph file path
 		path = Glib::build_filename(path, get_basename(path) + ".ttl");
 	}
 
@@ -572,7 +572,7 @@ Parser::parse_file(Ingen::World*                            world,
 	SerdNode       base_node = serd_node_from_string(SERD_URI, uri_c_str);
 	SerdEnv*       env       = serd_env_new(&base_node);
 
-	// Load patch file into model
+	// Load graph file into model
 	Sord::Model model(*world->rdf_world(), uri, SORD_SPO|SORD_PSO, false);
 	model.load_file(env, SERD_TURTLE, uri);
 
diff --git a/src/serialisation/Serialiser.cpp b/src/serialisation/Serialiser.cpp
index a9d49fe3..e1b1548d 100644
--- a/src/serialisation/Serialiser.cpp
+++ b/src/serialisation/Serialiser.cpp
@@ -66,7 +66,7 @@ struct Serialiser::Impl {
 
 	void start_to_filename(const std::string& filename);
 
-	void serialise_patch(SharedPtr<const GraphObject> p,
+	void serialise_graph(SharedPtr<const GraphObject> p,
 	                     const Sord::Node&            id);
 
 	void serialise_block(SharedPtr<const GraphObject> n,
@@ -80,14 +80,14 @@ struct Serialiser::Impl {
 	void serialise_properties(Sord::Node                  id,
 	                          const Resource::Properties& props);
 
-	void write_bundle(SharedPtr<const GraphObject> patch,
+	void write_bundle(SharedPtr<const GraphObject> graph,
 	                  const std::string&           uri);
 
 	Sord::Node path_rdf_node(const Raul::Path& path);
 
 	void write_manifest(const std::string&           bundle_path,
-	                    SharedPtr<const GraphObject> patch,
-	                    const std::string&           patch_symbol);
+	                    SharedPtr<const GraphObject> graph,
+	                    const std::string&           graph_symbol);
 
 	void serialise_edge(const Sord::Node& parent,
 	                    SharedPtr<const Edge> c)
@@ -124,8 +124,8 @@ Serialiser::to_file(SharedPtr<const GraphObject> object,
 
 void
 Serialiser::Impl::write_manifest(const std::string&           bundle_path,
-                                 SharedPtr<const GraphObject> patch,
-                                 const std::string&           patch_symbol)
+                                 SharedPtr<const GraphObject> graph,
+                                 const std::string&           graph_symbol)
 {
 	const string manifest_path(Glib::build_filename(bundle_path, "manifest.ttl"));
 	const string binary_path(Glib::Module::build_path("", "ingen_lv2"));
@@ -135,12 +135,12 @@ Serialiser::Impl::write_manifest(const std::string&           bundle_path,
 	Sord::World& world = _model->world();
 	const URIs&  uris  = _world.uris();
 
-	const string    filename(patch_symbol + ".ttl");
+	const string    filename(graph_symbol + ".ttl");
 	const Sord::URI subject(world, filename, _base_uri);
 
 	_model->add_statement(subject,
 	                      Sord::URI(world, uris.rdf_type),
-	                      Sord::URI(world, uris.ingen_Patch));
+	                      Sord::URI(world, uris.ingen_Graph));
 	_model->add_statement(subject,
 	                      Sord::URI(world, uris.rdf_type),
 	                      Sord::URI(world, uris.lv2_Plugin));
@@ -158,14 +158,14 @@ Serialiser::Impl::write_manifest(const std::string&           bundle_path,
 }
 
 void
-Serialiser::write_bundle(SharedPtr<const GraphObject> patch,
+Serialiser::write_bundle(SharedPtr<const GraphObject> graph,
                          const std::string&           path)
 {
-	me->write_bundle(patch, path);
+	me->write_bundle(graph, path);
 }
 
 void
-Serialiser::Impl::write_bundle(SharedPtr<const GraphObject> patch,
+Serialiser::Impl::write_bundle(SharedPtr<const GraphObject> graph,
                                const std::string&           a_path)
 {
 	std::string path = Glib::filename_from_uri(a_path);
@@ -186,12 +186,12 @@ Serialiser::Impl::write_bundle(SharedPtr<const GraphObject> patch,
 
 	start_to_filename(root_file);
 	const Raul::Path old_root_path = _root_path;
-	_root_path = patch->path();
-	serialise_patch(patch, Sord::URI(_model->world(), root_file, _base_uri));
+	_root_path = graph->path();
+	serialise_graph(graph, Sord::URI(_model->world(), root_file, _base_uri));
 	_root_path = old_root_path;
 	finish();
 
-	write_manifest(path, patch, symbol);
+	write_manifest(path, graph, symbol);
 }
 
 string
@@ -284,8 +284,8 @@ Serialiser::serialise(SharedPtr<const GraphObject> object) throw (std::logic_err
 	if (!me->_model)
 		throw std::logic_error("serialise called without serialisation in progress");
 
-	if (object->graph_type() == GraphObject::PATCH) {
-		me->serialise_patch(object, me->path_rdf_node(object->path()));
+	if (object->graph_type() == GraphObject::GRAPH) {
+		me->serialise_graph(object, me->path_rdf_node(object->path()));
 	} else if (object->graph_type() == GraphObject::BLOCK) {
 		const Sord::URI plugin_id(me->_model->world(), object->plugin()->uri());
 		me->serialise_block(object, plugin_id, me->path_rdf_node(object->path()));
@@ -300,122 +300,122 @@ Serialiser::serialise(SharedPtr<const GraphObject> object) throw (std::logic_err
 }
 
 void
-Serialiser::Impl::serialise_patch(SharedPtr<const GraphObject> patch,
-                                  const Sord::Node&            patch_id)
+Serialiser::Impl::serialise_graph(SharedPtr<const GraphObject> graph,
+                                  const Sord::Node&            graph_id)
 {
 	Sord::World& world = _model->world();
 	const URIs&  uris  = _world.uris();
 
-	_model->add_statement(patch_id,
+	_model->add_statement(graph_id,
 	                      Sord::URI(world, uris.rdf_type),
-	                      Sord::URI(world, uris.ingen_Patch));
+	                      Sord::URI(world, uris.ingen_Graph));
 
-	_model->add_statement(patch_id,
+	_model->add_statement(graph_id,
 	                      Sord::URI(world, uris.rdf_type),
 	                      Sord::URI(world, uris.lv2_Plugin));
 
-	_model->add_statement(patch_id,
+	_model->add_statement(graph_id,
 	                      Sord::URI(world, uris.lv2_extensionData),
 	                      Sord::URI(world, LV2_STATE__interface));
 
-	_model->add_statement(patch_id,
+	_model->add_statement(graph_id,
 	                      Sord::URI(world, LV2_UI__ui),
-	                      Sord::URI(world, "http://drobilla.net/ns/ingen#PatchUIGtk2"));
+	                      Sord::URI(world, "http://drobilla.net/ns/ingen#GraphUIGtk2"));
 
 	// Always write a symbol (required by Ingen)
 	Raul::Symbol symbol("_");
-	GraphObject::Properties::const_iterator s = patch->properties().find(uris.lv2_symbol);
-	if (s == patch->properties().end()
+	GraphObject::Properties::const_iterator s = graph->properties().find(uris.lv2_symbol);
+	if (s == graph->properties().end()
 	    || !s->second.type() == _world.forge().String
 	    || !Raul::Symbol::is_valid(s->second.get_string())) {
 		const std::string base = Glib::path_get_basename(
 			_model->base_uri().to_c_string());
 		symbol = Raul::Symbol::symbolify(base.substr(0, base.find('.')));
 		_model->add_statement(
-			patch_id,
+			graph_id,
 			Sord::URI(world, uris.lv2_symbol),
 			Sord::Literal(world, symbol.c_str()));
 	} else {
 		symbol = Raul::Symbol::symbolify(s->second.get_string());
 	}
 
-	// If the patch has no doap:name (required by LV2), use the symbol
-	if (patch->properties().find(uris.doap_name) == patch->properties().end())
-		_model->add_statement(patch_id,
+	// If the graph has no doap:name (required by LV2), use the symbol
+	if (graph->properties().find(uris.doap_name) == graph->properties().end())
+		_model->add_statement(graph_id,
 		                      Sord::URI(world, uris.doap_name),
 		                      Sord::Literal(world, symbol.c_str()));
 
-	const GraphObject::Properties props = patch->properties(Resource::INTERNAL);
-	serialise_properties(patch_id, props);
+	const GraphObject::Properties props = graph->properties(Resource::INTERNAL);
+	serialise_properties(graph_id, props);
 
-	const Store::const_range kids = _world.store()->children_range(patch);
+	const Store::const_range kids = _world.store()->children_range(graph);
 	for (Store::const_iterator n = kids.first; n != kids.second; ++n) {
-		if (n->first.parent() != patch->path())
+		if (n->first.parent() != graph->path())
 			continue;
 
-		if (n->second->graph_type() == GraphObject::PATCH) {
-			SharedPtr<GraphObject> subpatch = n->second;
+		if (n->second->graph_type() == GraphObject::GRAPH) {
+			SharedPtr<GraphObject> subgraph = n->second;
 
 			SerdURI base_uri;
 			serd_uri_parse((const uint8_t*)_base_uri.c_str(), &base_uri);
 
-			const string sub_bundle_path = subpatch->path().substr(1) + ".ingen";
+			const string sub_bundle_path = subgraph->path().substr(1) + ".ingen";
 
-			SerdURI  subpatch_uri;
-			SerdNode subpatch_node = serd_node_new_uri_from_string(
+			SerdURI  subgraph_uri;
+			SerdNode subgraph_node = serd_node_new_uri_from_string(
 				(const uint8_t*)sub_bundle_path.c_str(),
 				&base_uri,
-				&subpatch_uri);
+				&subgraph_uri);
 
-			const Sord::URI subpatch_id(world, (const char*)subpatch_node.buf);
+			const Sord::URI subgraph_id(world, (const char*)subgraph_node.buf);
 
 			// Save our state
 			std::string  my_base_uri = _base_uri;
 			Sord::Model* my_model    = _model;
 
 			// Write child bundle within this bundle
-			write_bundle(subpatch, subpatch_id.to_string());
+			write_bundle(subgraph, subgraph_id.to_string());
 
 			// Restore our state
 			_base_uri = my_base_uri;
 			_model    = my_model;
 
-			// Serialise reference to patch block
-			const Sord::Node block_id(path_rdf_node(subpatch->path()));
-			_model->add_statement(patch_id,
+			// Serialise reference to graph block
+			const Sord::Node block_id(path_rdf_node(subgraph->path()));
+			_model->add_statement(graph_id,
 			                      Sord::URI(world, uris.ingen_block),
 			                      block_id);
-			serialise_block(subpatch, subpatch_id, block_id);
+			serialise_block(subgraph, subgraph_id, block_id);
 		} else if (n->second->graph_type() == GraphObject::BLOCK) {
 			SharedPtr<const GraphObject> block = n->second;
 
 			const Sord::URI  class_id(world, block->plugin()->uri());
 			const Sord::Node block_id(path_rdf_node(n->second->path()));
-			_model->add_statement(patch_id,
+			_model->add_statement(graph_id,
 			                      Sord::URI(world, uris.ingen_block),
 			                      block_id);
 			serialise_block(block, class_id, block_id);
 		}
 	}
 
-	for (uint32_t i = 0; i < patch->num_ports(); ++i) {
-		GraphObject* p = patch->port(i);
+	for (uint32_t i = 0; i < graph->num_ports(); ++i) {
+		GraphObject* p = graph->port(i);
 		const Sord::Node port_id = path_rdf_node(p->path());
 
-		// Ensure lv2:name always exists so Patch is a valid LV2 plugin
+		// Ensure lv2:name always exists so Graph is a valid LV2 plugin
 		if (p->properties().find(uris.lv2_name) == p->properties().end())
 			p->set_property(uris.lv2_name,
 			                _world.forge().alloc(p->symbol().c_str()));
 
-		_model->add_statement(patch_id,
+		_model->add_statement(graph_id,
 		                      Sord::URI(world, LV2_CORE__port),
 		                      port_id);
 		serialise_port(p, Resource::INTERNAL, port_id);
 	}
 
-	for (GraphObject::Edges::const_iterator c = patch->edges().begin();
-	     c != patch->edges().end(); ++c) {
-		serialise_edge(patch_id, c->second);
+	for (GraphObject::Edges::const_iterator c = graph->edges().begin();
+	     c != graph->edges().end(); ++c) {
+		serialise_edge(graph_id, c->second);
 	}
 }
 
diff --git a/src/server/BlockImpl.cpp b/src/server/BlockImpl.cpp
index 7d99ca28..2ccb0e2f 100644
--- a/src/server/BlockImpl.cpp
+++ b/src/server/BlockImpl.cpp
@@ -22,7 +22,7 @@
 #include "Buffer.hpp"
 #include "Engine.hpp"
 #include "BlockImpl.hpp"
-#include "PatchImpl.hpp"
+#include "GraphImpl.hpp"
 #include "PluginImpl.hpp"
 #include "PortImpl.hpp"
 #include "ProcessContext.hpp"
@@ -36,7 +36,7 @@ namespace Server {
 BlockImpl::BlockImpl(PluginImpl*         plugin,
                      const Raul::Symbol& symbol,
                      bool                polyphonic,
-                     PatchImpl*          parent,
+                     GraphImpl*          parent,
                      SampleRate          srate)
 	: GraphObjectImpl(plugin->uris(), parent, symbol)
 	, _plugin(plugin)
@@ -58,7 +58,7 @@ BlockImpl::~BlockImpl()
 	}
 
 	if (is_linked()) {
-		parent_patch()->remove_block(*this);
+		parent_graph()->remove_block(*this);
 	}
 
 	delete _ports;
diff --git a/src/server/BlockImpl.hpp b/src/server/BlockImpl.hpp
index fd2af927..12318d60 100644
--- a/src/server/BlockImpl.hpp
+++ b/src/server/BlockImpl.hpp
@@ -43,12 +43,12 @@ namespace Server {
 class Buffer;
 class BufferFactory;
 class Context;
-class PatchImpl;
+class GraphImpl;
 class PluginImpl;
 class PortImpl;
 class ProcessContext;
 
-/** A Block in a Patch (which is also a Block).
+/** A Block in a Graph (which is also a Block).
  *
  * This is what is often called a "Module" in modular synthesizers.  A Block is
  * a unit with input/output ports, a process() method, and some other things.
@@ -56,13 +56,13 @@ class ProcessContext;
  * \ingroup engine
  */
 class BlockImpl : public GraphObjectImpl
-                , public boost::intrusive::slist_base_hook<>  // In PatchImpl
+                , public boost::intrusive::slist_base_hook<>  // In GraphImpl
 {
 public:
 	BlockImpl(PluginImpl*         plugin,
 	          const Raul::Symbol& symbol,
 	          bool                poly,
-	          PatchImpl*          parent,
+	          GraphImpl*          parent,
 	          SampleRate          rate);
 
 	virtual ~BlockImpl();
@@ -72,7 +72,7 @@ public:
 	/** Activate this Block.
 	 *
 	 * This function must be called in a non-realtime thread before it is
-	 * inserted in to a patch.  Any non-realtime actions that need to be
+	 * inserted in to a graph.  Any non-realtime actions that need to be
 	 * done before the Block is ready for use should be done here.
 	 */
 	virtual void activate(BufferFactory& bufs);
@@ -80,7 +80,7 @@ public:
 	/** Deactivate this Block.
 	 *
 	 * This function must be called in a non-realtime thread after the
-	 * block has been removed from its patch (i.e. processing is finished).
+	 * block has been removed from its graph (i.e. processing is finished).
 	 */
 	virtual void deactivate();
 
@@ -130,12 +130,12 @@ public:
 		ProcessContext& context, Raul::Maid& maid, uint32_t poly);
 
 	/** Information about the Plugin this Block is an instance of.
-	 * Not the best name - not all blocks come from plugins (e.g. Patch)
+	 * Not the best name - not all blocks come from plugins (e.g. Graph)
 	 */
 	virtual PluginImpl* plugin_impl() const { return _plugin; }
 
 	/** Information about the Plugin this Block is an instance of.
-	 * Not the best name - not all blocks come from plugins (ie Patch)
+	 * Not the best name - not all blocks come from plugins (ie Graph)
 	 */
 	virtual const Plugin* plugin() const;
 
@@ -146,8 +146,8 @@ public:
 	                             LV2_URID       type,
 	                             uint32_t       size);
 
-	/** The Patch this Block belongs to. */
-	inline PatchImpl* parent_patch() const { return (PatchImpl*)_parent; }
+	/** The Graph this Block belongs to. */
+	inline GraphImpl* parent_graph() const { return (GraphImpl*)_parent; }
 
 	Context::ID      context()   const { return _context; }
 	uint32_t         num_ports() const { return _ports ? _ports->size() : 0; }
diff --git a/src/server/Broadcaster.hpp b/src/server/Broadcaster.hpp
index 0bc7576a..3af4e5b7 100644
--- a/src/server/Broadcaster.hpp
+++ b/src/server/Broadcaster.hpp
@@ -89,9 +89,9 @@ public:
 		BROADCAST(disconnect, tail, head);
 	}
 
-	void disconnect_all(const Raul::Path& parent_patch_path,
+	void disconnect_all(const Raul::Path& graph,
 	                    const Raul::Path& path) {
-		BROADCAST(disconnect_all, parent_patch_path, path);
+		BROADCAST(disconnect_all, graph, path);
 	}
 
 	void set_property(const Raul::URI&  subject,
diff --git a/src/server/CompiledPatch.hpp b/src/server/CompiledGraph.hpp
index 15d1137a..024aa919 100644
--- a/src/server/CompiledPatch.hpp
+++ b/src/server/CompiledGraph.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_ENGINE_COMPILEDPATCH_HPP
-#define INGEN_ENGINE_COMPILEDPATCH_HPP
+#ifndef INGEN_ENGINE_COMPILEDGRAPH_HPP
+#define INGEN_ENGINE_COMPILEDGRAPH_HPP
 
 #include <vector>
 #include <list>
@@ -54,7 +54,7 @@ private:
 	std::vector<BlockImpl*> _dependants; ///< Blocks this one's output ports are connected to
 };
 
-/** A patch ``compiled'' into a flat structure with the correct order so
+/** A graph ``compiled'' into a flat structure with the correct order so
  * the audio thread(s) can execute it without threading problems (since
  * the preprocessor thread modifies the graph).
  *
@@ -62,7 +62,7 @@ private:
  * The parallel processing algorithm guarantees no block will be executed
  * before its providers, using this order as well as semaphores.
  */
-class CompiledPatch : public std::vector<CompiledBlock>
+class CompiledGraph : public std::vector<CompiledBlock>
                     , public Raul::Disposable
                     , public Raul::Noncopyable
 {
@@ -71,4 +71,4 @@ class CompiledPatch : public std::vector<CompiledBlock>
 } // namespace Server
 } // namespace Ingen
 
-#endif // INGEN_ENGINE_COMPILEDPATCH_HPP
+#endif // INGEN_ENGINE_COMPILEDGRAPH_HPP
diff --git a/src/server/ControlBindings.cpp b/src/server/ControlBindings.cpp
index de6818ff..e8f595fa 100644
--- a/src/server/ControlBindings.cpp
+++ b/src/server/ControlBindings.cpp
@@ -429,7 +429,7 @@ ControlBindings::pre_process(ProcessContext& context, Buffer* buffer)
 void
 ControlBindings::post_process(ProcessContext& context, Buffer* buffer)
 {
-	// TODO: merge buffer's existing contents (anything send to it in the patch)
+	// TODO: merge buffer's existing contents (anything send to it in the graph)
 	buffer->copy(context, _feedback.get());
 }
 
diff --git a/src/server/DirectDriver.hpp b/src/server/DirectDriver.hpp
index 76cd3cbc..5fde93d9 100644
--- a/src/server/DirectDriver.hpp
+++ b/src/server/DirectDriver.hpp
@@ -38,7 +38,7 @@ public:
 
 	virtual void deactivate() {}
 
-	virtual EnginePort* create_port(DuplexPort* patch_port) {
+	virtual EnginePort* create_port(DuplexPort* graph_port) {
 		return NULL;
 	}
 
diff --git a/src/server/Driver.hpp b/src/server/Driver.hpp
index e038b2bc..e5c62623 100644
--- a/src/server/Driver.hpp
+++ b/src/server/Driver.hpp
@@ -34,7 +34,7 @@ class EnginePort;
 
 /** Engine driver base class.
  *
- * A Driver is, from the perspective of GraphObjects (blocks, patches, ports)
+ * A Driver is, from the perspective of GraphObjects (blocks, graphs, ports)
  * an interface for managing system ports.  An implementation of Driver
  * basically needs to manage EnginePorts, and handle writing/reading data
  * to/from them.
@@ -54,12 +54,12 @@ public:
 	/** Create a port ready to be inserted with add_input (non realtime).
 	 * May return NULL if the Driver can not create the port for some reason.
 	 */
-	virtual EnginePort* create_port(DuplexPort* patch_port) = 0;
+	virtual EnginePort* create_port(DuplexPort* graph_port) = 0;
 
 	/** Find a system port by path. */
 	virtual EnginePort* get_port(const Raul::Path& path) = 0;
 
-	/** Add a system visible port (e.g. a port on the root patch). */
+	/** Add a system visible port (e.g. a port on the root graph). */
 	virtual void add_port(ProcessContext& context, EnginePort* port) = 0;
 
 	/** Remove a system visible port.
diff --git a/src/server/DuplexPort.cpp b/src/server/DuplexPort.cpp
index 43197844..34c9b590 100644
--- a/src/server/DuplexPort.cpp
+++ b/src/server/DuplexPort.cpp
@@ -18,8 +18,8 @@
 
 #include "Buffer.hpp"
 #include "DuplexPort.hpp"
+#include "GraphImpl.hpp"
 #include "OutputPort.hpp"
-#include "PatchImpl.hpp"
 
 using namespace std;
 
@@ -49,7 +49,7 @@ DuplexPort::DuplexPort(BufferFactory&      bufs,
 DuplexPort::~DuplexPort()
 {
 	if (is_linked()) {
-		parent_patch()->remove_port(*this);
+		parent_graph()->remove_port(*this);
 	}
 }
 
@@ -69,34 +69,34 @@ DuplexPort::get_buffers(BufferFactory&          bufs,
 uint32_t
 DuplexPort::max_tail_poly(Context& context) const
 {
-	return parent_patch()->internal_poly_process();
+	return parent_graph()->internal_poly_process();
 }
 
-/** Prepare for the execution of parent patch */
+/** Prepare for the execution of parent graph */
 void
 DuplexPort::pre_process(Context& context)
 {
 	if (_is_output) {
-		/* This is a patch output, which is an input from the internal
+		/* This is a graph output, which is an input from the internal
 		   perspective.  Prepare buffers for write so plugins can deliver to
 		   them */
 		for (uint32_t v = 0; v < _poly; ++v) {
 			_buffers->at(v)->prepare_write(context);
 		}
 	} else {
-		/* This is a a patch input, which is an output from the internal
+		/* This is a a graph input, which is an output from the internal
 		   perspective.  Do whatever a normal block's input port does to
 		   prepare input for reading. */
 		InputPort::pre_process(context);
 	}
 }
 
-/** Finalize after the execution of parent patch (deliver outputs) */
+/** Finalize after the execution of parent graph (deliver outputs) */
 void
 DuplexPort::post_process(Context& context)
 {
 	if (_is_output) {
-		/* This is a patch output, which is an input from the internal
+		/* This is a graph output, which is an input from the internal
 		   perspective.  Mix down input delivered by plugins so output
 		   (external perspective) is ready. */
 		InputPort::pre_process(context);
diff --git a/src/server/DuplexPort.hpp b/src/server/DuplexPort.hpp
index 25d389c5..55ba8fa0 100644
--- a/src/server/DuplexPort.hpp
+++ b/src/server/DuplexPort.hpp
@@ -28,18 +28,18 @@ namespace Server {
 
 class BlockImpl;
 
-/** A duplex Port (both an InputPort and an OutputPort on a Patch)
+/** A duplex Port (both an InputPort and an OutputPort on a Graph)
  *
- * This is used for Patch ports, since they need to appear as both an input and
+ * This is used for Graph ports, since they need to appear as both an input and
  * an output port based on context.  There are no actual duplex ports in Ingen,
- * a Port is either an Input or Output.  This class only exists to allow Patch
- * outputs to appear as inputs from within that Patch, and vice versa.
+ * a Port is either an Input or Output.  This class only exists to allow Graph
+ * outputs to appear as inputs from within that Graph, and vice versa.
  *
  * \ingroup engine
  */
 class DuplexPort : public InputPort
                  , public OutputPort
-                 , public boost::intrusive::slist_base_hook<>  // In PatchImpl
+                 , public boost::intrusive::slist_base_hook<>  // In GraphImpl
 {
 public:
 	DuplexPort(BufferFactory&      bufs,
diff --git a/src/server/Engine.cpp b/src/server/Engine.cpp
index eada608a..7c053884 100644
--- a/src/server/Engine.cpp
+++ b/src/server/Engine.cpp
@@ -34,7 +34,7 @@
 #include "Engine.hpp"
 #include "Event.hpp"
 #include "EventWriter.hpp"
-#include "PatchImpl.hpp"
+#include "GraphImpl.hpp"
 #include "PostProcessor.hpp"
 #include "PreProcessor.hpp"
 #include "ProcessContext.hpp"
@@ -59,7 +59,7 @@ Engine::Engine(Ingen::World* world)
 	, _pre_processor(new PreProcessor())
 	, _post_processor(new PostProcessor(*this))
 	, _event_writer(new EventWriter(*this))
-	, _root_patch(NULL)
+	, _root_graph(NULL)
 	, _worker(new Worker(world->log(), event_queue_size()))
 	, _process_context(*this)
 	, _quit_flag(false)
@@ -185,20 +185,20 @@ Engine::activate()
 	const Ingen::URIs& uris  = world()->uris();
 	Forge&             forge = world()->forge();
 
-	// Create root patch
-	if (!_root_patch) {
-		_root_patch = new PatchImpl(
+	// Create root graph
+	if (!_root_graph) {
+		_root_graph = new GraphImpl(
 			*this, Raul::Symbol("root"), 1, NULL, _driver->sample_rate(), 1);
-		_root_patch->set_property(
+		_root_graph->set_property(
 			uris.rdf_type,
-			Resource::Property(uris.ingen_Patch, Resource::INTERNAL));
-		_root_patch->set_property(
+			Resource::Property(uris.ingen_Graph, Resource::INTERNAL));
+		_root_graph->set_property(
 			uris.ingen_polyphony,
 			Resource::Property(_world->forge().make(int32_t(1)),
 			                   Resource::INTERNAL));
-		_root_patch->activate(*_buffer_factory);
-		_world->store()->add(_root_patch);
-		_root_patch->compiled_patch(_root_patch->compile());
+		_root_graph->activate(*_buffer_factory);
+		_world->store()->add(_root_graph);
+		_root_graph->compiled_graph(_root_graph->compile());
 
 		ProcessContext context(*this);
 
@@ -249,7 +249,7 @@ Engine::activate()
 	}
 
 	_driver->activate();
-	_root_patch->enable();
+	_root_graph->enable();
 
 	ThreadManager::single_threaded = false;
 
@@ -265,8 +265,8 @@ Engine::deactivate()
 		_driver->deactivate();
 	}
 
-	if (_root_patch) {
-		_root_patch->deactivate();
+	if (_root_graph) {
+		_root_graph->deactivate();
 	}
 
 	ThreadManager::single_threaded = true;
@@ -279,7 +279,7 @@ Engine::run(uint32_t sample_count)
 
 	// Apply control bindings to input
 	control_bindings()->pre_process(
-		_process_context, _root_patch->port_impl(0)->buffer(0).get());
+		_process_context, _root_graph->port_impl(0)->buffer(0).get());
 
 	post_processor()->set_end_time(_process_context.end());
 
@@ -287,14 +287,14 @@ Engine::run(uint32_t sample_count)
 	// (Aiming for jitter-free 1 block event latency, ideally)
 	const unsigned n_processed_events = process_events();
 
-	// Run root patch
-	if (_root_patch) {
-		_root_patch->process(_process_context);
+	// Run root graph
+	if (_root_graph) {
+		_root_graph->process(_process_context);
 	}
 
 	// Emit control binding feedback
 	control_bindings()->post_process(
-		_process_context, _root_patch->port_impl(1)->buffer(0).get());
+		_process_context, _root_graph->port_impl(1)->buffer(0).get());
 
 	return n_processed_events;
 }
diff --git a/src/server/Engine.hpp b/src/server/Engine.hpp
index 66930938..2d49bde0 100644
--- a/src/server/Engine.hpp
+++ b/src/server/Engine.hpp
@@ -34,17 +34,17 @@ class World;
 
 namespace Server {
 
+class BlockFactory;
 class Broadcaster;
 class BufferFactory;
 class ControlBindings;
 class Driver;
 class Event;
 class EventWriter;
-class BlockFactory;
+class GraphImpl;
 class PostProcessor;
 class PreProcessor;
 class ProcessContext;
-class PatchImpl;
 class Worker;
 
 /**
@@ -98,7 +98,7 @@ public:
 	ControlBindings* control_bindings() const { return _control_bindings; }
 	Driver*          driver()           const { return _driver.get(); }
 	Log&             log()              const { return _world->log(); }
-	PatchImpl*       root_patch()       const { return _root_patch; }
+	GraphImpl*       root_graph()       const { return _root_graph; }
 	PostProcessor*   post_processor()   const { return _post_processor; }
 	Raul::Maid*      maid()             const { return _maid; }
 	Worker*          worker()           const { return _worker; }
@@ -121,7 +121,7 @@ private:
 	PreProcessor*     _pre_processor;
 	PostProcessor*    _post_processor;
 	EventWriter*      _event_writer;
-	PatchImpl*        _root_patch;
+	GraphImpl*        _root_graph;
 	Worker*           _worker;
 
 	ProcessContext _process_context;
diff --git a/src/server/EnginePort.hpp b/src/server/EnginePort.hpp
index 3bda2998..7154920b 100644
--- a/src/server/EnginePort.hpp
+++ b/src/server/EnginePort.hpp
@@ -37,7 +37,7 @@ class EnginePort : public Raul::Noncopyable
 {
 public:
 	explicit EnginePort(DuplexPort* port)
-		: _patch_port(port)
+		: _graph_port(port)
 		, _buffer(NULL)
 		, _handle(NULL)
 	{}
@@ -47,11 +47,11 @@ public:
 
 	void*       buffer()     const { return _buffer; }
 	void*       handle()     const { return _handle; }
-	DuplexPort* patch_port() const { return _patch_port; }
-	bool        is_input()   const { return _patch_port->is_input(); }
+	DuplexPort* graph_port() const { return _graph_port; }
+	bool        is_input()   const { return _graph_port->is_input(); }
 
 protected:
-	DuplexPort* _patch_port;
+	DuplexPort* _graph_port;
 	void*       _buffer;
 	void*       _handle;
 };
diff --git a/src/server/EventWriter.cpp b/src/server/EventWriter.cpp
index b4f95294..2b1b1bf6 100644
--- a/src/server/EventWriter.cpp
+++ b/src/server/EventWriter.cpp
@@ -103,12 +103,12 @@ EventWriter::disconnect(const Raul::Path& src,
 }
 
 void
-EventWriter::disconnect_all(const Raul::Path& patch_path,
+EventWriter::disconnect_all(const Raul::Path& graph,
                             const Raul::Path& path)
 {
 	_engine.enqueue_event(
 		new Events::DisconnectAll(_engine, _respondee, _request_id, now(),
-		                          patch_path, path));
+		                          graph, path));
 }
 
 void
diff --git a/src/server/EventWriter.hpp b/src/server/EventWriter.hpp
index 67b3b83b..5c44c5b6 100644
--- a/src/server/EventWriter.hpp
+++ b/src/server/EventWriter.hpp
@@ -79,7 +79,7 @@ public:
 
 	virtual void del(const Raul::URI& uri);
 
-	virtual void disconnect_all(const Raul::Path& parent_patch_path,
+	virtual void disconnect_all(const Raul::Path& graph,
 	                            const Raul::Path& path);
 
 	virtual void get(const Raul::URI& uri);
diff --git a/src/server/PatchImpl.cpp b/src/server/GraphImpl.cpp
index ae16c634..81c69b46 100644
--- a/src/server/PatchImpl.cpp
+++ b/src/server/GraphImpl.cpp
@@ -25,8 +25,8 @@
 #include "DuplexPort.hpp"
 #include "EdgeImpl.hpp"
 #include "Engine.hpp"
-#include "PatchImpl.hpp"
-#include "PatchPlugin.hpp"
+#include "GraphImpl.hpp"
+#include "GraphPlugin.hpp"
 #include "PortImpl.hpp"
 #include "ThreadManager.hpp"
 
@@ -35,35 +35,35 @@ using namespace std;
 namespace Ingen {
 namespace Server {
 
-PatchImpl::PatchImpl(Engine&             engine,
+GraphImpl::GraphImpl(Engine&             engine,
                      const Raul::Symbol& symbol,
                      uint32_t            poly,
-                     PatchImpl*          parent,
+                     GraphImpl*          parent,
                      SampleRate          srate,
                      uint32_t            internal_poly)
-	: BlockImpl(new PatchPlugin(engine.world()->uris(),
-	                            engine.world()->uris().ingen_Patch,
-	                            Raul::Symbol("patch"),
-	                            "Ingen Patch"),
+	: BlockImpl(new GraphPlugin(engine.world()->uris(),
+	                            engine.world()->uris().ingen_Graph,
+	                            Raul::Symbol("graph"),
+	                            "Ingen Graph"),
 	           symbol, poly, parent, srate)
 	, _engine(engine)
 	, _poly_pre(internal_poly)
 	, _poly_process(internal_poly)
-	, _compiled_patch(NULL)
+	, _compiled_graph(NULL)
 	, _process(false)
 {
 	assert(internal_poly >= 1);
 	assert(internal_poly <= 128);
 }
 
-PatchImpl::~PatchImpl()
+GraphImpl::~GraphImpl()
 {
-	delete _compiled_patch;
+	delete _compiled_graph;
 	delete _plugin;
 }
 
 void
-PatchImpl::activate(BufferFactory& bufs)
+GraphImpl::activate(BufferFactory& bufs)
 {
 	BlockImpl::activate(bufs);
 
@@ -75,7 +75,7 @@ PatchImpl::activate(BufferFactory& bufs)
 }
 
 void
-PatchImpl::deactivate()
+GraphImpl::deactivate()
 {
 	if (_activated) {
 		BlockImpl::deactivate();
@@ -89,7 +89,7 @@ PatchImpl::deactivate()
 }
 
 void
-PatchImpl::disable(ProcessContext& context)
+GraphImpl::disable(ProcessContext& context)
 {
 	_process = false;
 	for (Ports::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
@@ -98,11 +98,11 @@ PatchImpl::disable(ProcessContext& context)
 }
 
 bool
-PatchImpl::prepare_internal_poly(BufferFactory& bufs, uint32_t poly)
+GraphImpl::prepare_internal_poly(BufferFactory& bufs, uint32_t poly)
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
 
-	// TODO: Subpatch dynamic polyphony (i.e. changing port polyphony)
+	// TODO: Subgraph dynamic polyphony (i.e. changing port polyphony)
 
 	for (Blocks::iterator i = _blocks.begin(); i != _blocks.end(); ++i) {
 		i->prepare_poly(bufs, poly);
@@ -113,12 +113,12 @@ PatchImpl::prepare_internal_poly(BufferFactory& bufs, uint32_t poly)
 }
 
 bool
-PatchImpl::apply_internal_poly(ProcessContext& context,
+GraphImpl::apply_internal_poly(ProcessContext& context,
                                BufferFactory&  bufs,
                                Raul::Maid&     maid,
                                uint32_t        poly)
 {
-	// TODO: Subpatch dynamic polyphony (i.e. changing port polyphony)
+	// TODO: Subgraph dynamic polyphony (i.e. changing port polyphony)
 
 	for (Blocks::iterator i = _blocks.begin(); i != _blocks.end(); ++i) {
 		i->apply_poly(context, maid, poly);
@@ -133,7 +133,7 @@ PatchImpl::apply_internal_poly(ProcessContext& context,
 		}
 	}
 
-	const bool polyphonic = parent_patch() && (poly == parent_patch()->internal_poly_process());
+	const bool polyphonic = parent_graph() && (poly == parent_graph()->internal_poly_process());
 	for (Ports::iterator i = _outputs.begin(); i != _outputs.end(); ++i)
 		i->setup_buffers(bufs, polyphonic ? poly : 1, true);
 
@@ -141,22 +141,22 @@ PatchImpl::apply_internal_poly(ProcessContext& context,
 	return true;
 }
 
-/** Run the patch for the specified number of frames.
+/** Run the graph for the specified number of frames.
  *
- * Calls all Blocks in (roughly, if parallel) the order _compiled_patch specifies.
+ * Calls all Blocks in (roughly, if parallel) the order _compiled_graph specifies.
  */
 void
-PatchImpl::process(ProcessContext& context)
+GraphImpl::process(ProcessContext& context)
 {
 	if (!_process)
 		return;
 
 	BlockImpl::pre_process(context);
 
-	if (_compiled_patch && _compiled_patch->size() > 0) {
+	if (_compiled_graph && _compiled_graph->size() > 0) {
 		// Run all blocks
-		for (size_t i = 0; i < _compiled_patch->size(); ++i) {
-			(*_compiled_patch)[i].block()->process(context);
+		for (size_t i = 0; i < _compiled_graph->size(); ++i) {
+			(*_compiled_graph)[i].block()->process(context);
 		}
 	}
 
@@ -164,24 +164,24 @@ PatchImpl::process(ProcessContext& context)
 }
 
 void
-PatchImpl::set_buffer_size(Context&       context,
+GraphImpl::set_buffer_size(Context&       context,
                            BufferFactory& bufs,
                            LV2_URID       type,
                            uint32_t       size)
 {
 	BlockImpl::set_buffer_size(context, bufs, type, size);
 
-	for (size_t i = 0; i < _compiled_patch->size(); ++i)
-		(*_compiled_patch)[i].block()->set_buffer_size(context, bufs, type, size);
+	for (size_t i = 0; i < _compiled_graph->size(); ++i)
+		(*_compiled_graph)[i].block()->set_buffer_size(context, bufs, type, size);
 }
 
-// Patch specific stuff
+// Graph specific stuff
 
 /** Add a block.
  * Preprocessing thread only.
  */
 void
-PatchImpl::add_block(BlockImpl& block)
+GraphImpl::add_block(BlockImpl& block)
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
 	_blocks.push_front(block);
@@ -191,13 +191,13 @@ PatchImpl::add_block(BlockImpl& block)
  * Preprocessing thread only.
  */
 void
-PatchImpl::remove_block(BlockImpl& block)
+GraphImpl::remove_block(BlockImpl& block)
 {
 	_blocks.erase(_blocks.iterator_to(block));
 }
 
 void
-PatchImpl::add_edge(SharedPtr<EdgeImpl> c)
+GraphImpl::add_edge(SharedPtr<EdgeImpl> c)
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
 	_edges.insert(make_pair(make_pair(c->tail(), c->head()), c));
@@ -207,7 +207,7 @@ PatchImpl::add_edge(SharedPtr<EdgeImpl> c)
  * Preprocessing thread only.
  */
 SharedPtr<EdgeImpl>
-PatchImpl::remove_edge(const PortImpl* tail, const PortImpl* dst_port)
+GraphImpl::remove_edge(const PortImpl* tail, const PortImpl* dst_port)
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
 	Edges::iterator i = _edges.find(make_pair(tail, dst_port));
@@ -221,7 +221,7 @@ PatchImpl::remove_edge(const PortImpl* tail, const PortImpl* dst_port)
 }
 
 bool
-PatchImpl::has_edge(const PortImpl* tail, const PortImpl* dst_port) const
+GraphImpl::has_edge(const PortImpl* tail, const PortImpl* dst_port) const
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
 	Edges::const_iterator i = _edges.find(make_pair(tail, dst_port));
@@ -229,7 +229,7 @@ PatchImpl::has_edge(const PortImpl* tail, const PortImpl* dst_port) const
 }
 
 uint32_t
-PatchImpl::num_ports_non_rt() const
+GraphImpl::num_ports_non_rt() const
 {
 	ThreadManager::assert_not_thread(THREAD_PROCESS);
 	return _inputs.size() + _outputs.size();
@@ -238,7 +238,7 @@ PatchImpl::num_ports_non_rt() const
 /** Create a port.  Not realtime safe.
  */
 DuplexPort*
-PatchImpl::create_port(BufferFactory&      bufs,
+GraphImpl::create_port(BufferFactory&      bufs,
                        const Raul::Symbol& symbol,
                        PortType            type,
                        LV2_URID            buffer_type,
@@ -268,7 +268,7 @@ PatchImpl::create_port(BufferFactory&      bufs,
  * Realtime safe.  Preprocessing thread only.
  */
 void
-PatchImpl::remove_port(DuplexPort& port)
+GraphImpl::remove_port(DuplexPort& port)
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
 
@@ -287,7 +287,7 @@ PatchImpl::remove_port(DuplexPort& port)
  * Realtime safe.  Preprocessing thread only.
  */
 void
-PatchImpl::clear_ports()
+GraphImpl::clear_ports()
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
 
@@ -296,7 +296,7 @@ PatchImpl::clear_ports()
 }
 
 Raul::Array<PortImpl*>*
-PatchImpl::build_ports_array()
+GraphImpl::build_ports_array()
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
 
@@ -317,7 +317,7 @@ PatchImpl::build_ports_array()
 }
 
 static inline void
-compile_recursive(BlockImpl* n, CompiledPatch* output)
+compile_recursive(BlockImpl* n, CompiledGraph* output)
 {
 	if (n == NULL || n->traversed())
 		return;
@@ -333,9 +333,9 @@ compile_recursive(BlockImpl* n, CompiledPatch* output)
 	output->push_back(CompiledBlock(n, n->providers().size(), n->dependants()));
 }
 
-/** Find the process order for this Patch.
+/** Find the process order for this Graph.
  *
- * The process order is a flat list that the patch will execute in order
+ * The process order is a flat list that the graph will execute in order
  * when its run() method is called.  Return value is a newly allocated list
  * which the caller is reponsible to delete.  Note that this function does
  * NOT actually set the process order, it is returned so it can be inserted
@@ -343,12 +343,12 @@ compile_recursive(BlockImpl* n, CompiledPatch* output)
  *
  * Not realtime safe.
  */
-CompiledPatch*
-PatchImpl::compile()
+CompiledGraph*
+GraphImpl::compile()
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
 
-	CompiledPatch* const compiled_patch = new CompiledPatch();
+	CompiledGraph* const compiled_graph = new CompiledGraph();
 
 	for (Blocks::iterator i = _blocks.begin(); i != _blocks.end(); ++i) {
 		i->traversed(false);
@@ -357,24 +357,24 @@ PatchImpl::compile()
 	for (Blocks::iterator i = _blocks.begin(); i != _blocks.end(); ++i) {
 		// Either a sink or connected to our output ports:
 		if (!i->traversed() && i->dependants().empty()) {
-			compile_recursive(&*i, compiled_patch);
+			compile_recursive(&*i, compiled_graph);
 		}
 	}
 
 	// Traverse any blocks we didn't hit yet
 	for (Blocks::iterator i = _blocks.begin(); i != _blocks.end(); ++i) {
 		if (!i->traversed()) {
-			compile_recursive(&*i, compiled_patch);
+			compile_recursive(&*i, compiled_graph);
 		}
 	}
 
-	if (compiled_patch->size() != _blocks.size()) {
-		_engine.log().error(Raul::fmt("Failed to compile patch %1%\n") % _path);
-		delete compiled_patch;
+	if (compiled_graph->size() != _blocks.size()) {
+		_engine.log().error(Raul::fmt("Failed to compile graph %1%\n") % _path);
+		delete compiled_graph;
 		return NULL;
 	}
 
-	return compiled_patch;
+	return compiled_graph;
 }
 
 } // namespace Server
diff --git a/src/server/PatchImpl.hpp b/src/server/GraphImpl.hpp
index fa212b1a..1eb0945e 100644
--- a/src/server/PatchImpl.hpp
+++ b/src/server/GraphImpl.hpp
@@ -14,13 +14,13 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_ENGINE_PATCHIMPL_HPP
-#define INGEN_ENGINE_PATCHIMPL_HPP
+#ifndef INGEN_ENGINE_GRAPHIMPL_HPP
+#define INGEN_ENGINE_GRAPHIMPL_HPP
 
 #include <cstdlib>
 
 #include "BlockImpl.hpp"
-#include "CompiledPatch.hpp"
+#include "CompiledGraph.hpp"
 #include "DuplexPort.hpp"
 #include "PluginImpl.hpp"
 #include "PortType.hpp"
@@ -32,33 +32,33 @@ class Edge;
 
 namespace Server {
 
-class CompiledPatch;
-class EdgeImpl;
+class CompiledGraph;
 class Context;
+class EdgeImpl;
 class Engine;
 class ProcessContext;
 
 /** A group of blocks in a graph, possibly polyphonic.
  *
  * Note that this is also a Block, just one which contains Blocks.
- * Therefore infinite subpatching is possible, of polyphonic
- * patches of polyphonic blocks etc. etc.
+ * Therefore infinite subgraphing is possible, of polyphonic
+ * graphes of polyphonic blocks etc. etc.
  *
  * \ingroup engine
  */
-class PatchImpl : public BlockImpl
+class GraphImpl : public BlockImpl
 {
 public:
-	PatchImpl(Engine&             engine,
+	GraphImpl(Engine&             engine,
 	          const Raul::Symbol& symbol,
 	          uint32_t            poly,
-	          PatchImpl*          parent,
+	          GraphImpl*          parent,
 	          SampleRate          srate,
 	          uint32_t            local_poly);
 
-	virtual ~PatchImpl();
+	virtual ~GraphImpl();
 
-	virtual GraphType graph_type() const { return PATCH; }
+	virtual GraphType graph_type() const { return GRAPH; }
 
 	void activate(BufferFactory& bufs);
 	void deactivate();
@@ -91,7 +91,7 @@ public:
 	                         Raul::Maid&     maid,
 	                         uint32_t        poly);
 
-	// Patch specific stuff not inherited from Block
+	// Graph specific stuff not inherited from Block
 
 	typedef boost::intrusive::slist<
 		BlockImpl, boost::intrusive::constant_time_size<true> > Blocks;
@@ -135,16 +135,16 @@ public:
 
 	bool has_edge(const PortImpl* tail, const PortImpl* head) const;
 
-	CompiledPatch* compiled_patch()                  { return _compiled_patch; }
-	void           compiled_patch(CompiledPatch* cp) { _compiled_patch = cp; }
+	CompiledGraph* compiled_graph()                  { return _compiled_graph; }
+	void           compiled_graph(CompiledGraph* cp) { _compiled_graph = cp; }
 
 	Raul::Array<PortImpl*>* external_ports()                           { return _ports; }
 	void                    external_ports(Raul::Array<PortImpl*>* pa) { _ports = pa; }
 
-	CompiledPatch*          compile();
+	CompiledGraph*          compile();
 	Raul::Array<PortImpl*>* build_ports_array();
 
-	/** Whether to run this patch's DSP bits in the audio thread */
+	/** Whether to run this graph's DSP bits in the audio thread */
 	bool enabled() const { return _process; }
 	void enable() { _process = true; }
 	void disable(ProcessContext& context);
@@ -158,7 +158,7 @@ private:
 	Engine&        _engine;
 	uint32_t       _poly_pre;        ///< Pre-process thread only
 	uint32_t       _poly_process;    ///< Process thread only
-	CompiledPatch* _compiled_patch;  ///< Process thread only
+	CompiledGraph* _compiled_graph;  ///< Process thread only
 	Ports          _inputs;          ///< Pre-process thread only
 	Ports          _outputs;         ///< Pre-process thread only
 	Blocks          _blocks;           ///< Pre-process thread only
@@ -168,4 +168,4 @@ private:
 } // namespace Server
 } // namespace Ingen
 
-#endif // INGEN_ENGINE_PATCHIMPL_HPP
+#endif // INGEN_ENGINE_GRAPHIMPL_HPP
diff --git a/src/server/GraphObjectImpl.cpp b/src/server/GraphObjectImpl.cpp
index d5608b0f..2df7943f 100644
--- a/src/server/GraphObjectImpl.cpp
+++ b/src/server/GraphObjectImpl.cpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include "GraphImpl.hpp"
 #include "GraphObjectImpl.hpp"
-#include "PatchImpl.hpp"
 #include "ThreadManager.hpp"
 
 using namespace std;
@@ -42,10 +42,10 @@ GraphObjectImpl::get_property(const Raul::URI& key) const
 	return (i != properties().end()) ? i->second : null_atom;
 }
 
-PatchImpl*
-GraphObjectImpl::parent_patch() const
+GraphImpl*
+GraphObjectImpl::parent_graph() const
 {
-	return dynamic_cast<PatchImpl*>((BlockImpl*)_parent);
+	return dynamic_cast<GraphImpl*>((BlockImpl*)_parent);
 }
 
 } // namespace Server
diff --git a/src/server/GraphObjectImpl.hpp b/src/server/GraphObjectImpl.hpp
index 5388981f..07a59727 100644
--- a/src/server/GraphObjectImpl.hpp
+++ b/src/server/GraphObjectImpl.hpp
@@ -35,12 +35,12 @@ namespace Shared { class URIs; }
 
 namespace Server {
 
-class PatchImpl;
+class BufferFactory;
 class Context;
+class GraphImpl;
 class ProcessContext;
-class BufferFactory;
 
-/** An object on the audio graph (a Patch, Block, or Port).
+/** An object on the audio graph (a Graph, Block, or Port).
  *
  * Each of these is a Raul::Deletable and so can be deleted in a realtime safe
  * way from anywhere, and they all have a map of variable for clients to store
@@ -70,8 +70,8 @@ public:
 
 	const Raul::Atom& get_property(const Raul::URI& key) const;
 
-	/** The Patch this object is a child of. */
-	virtual PatchImpl* parent_patch() const;
+	/** The Graph this object is a child of. */
+	virtual GraphImpl* parent_graph() const;
 
 	const Raul::Path& path() const { return _path; }
 
diff --git a/src/server/PatchPlugin.hpp b/src/server/GraphPlugin.hpp
index 1fd9069f..3b1e9bfa 100644
--- a/src/server/PatchPlugin.hpp
+++ b/src/server/GraphPlugin.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_ENGINE_PATCHPLUGIN_HPP
-#define INGEN_ENGINE_PATCHPLUGIN_HPP
+#ifndef INGEN_ENGINE_GRAPHPLUGIN_HPP
+#define INGEN_ENGINE_GRAPHPLUGIN_HPP
 
 #include <string>
 #include "PluginImpl.hpp"
@@ -25,31 +25,31 @@ namespace Server {
 
 class BlockImpl;
 
-/** Implementation of a Patch plugin.
+/** Implementation of a Graph plugin.
  *
- * Patches don't actually work like this yet...
+ * Graphs don't actually work like this yet...
  */
-class PatchPlugin : public PluginImpl
+class GraphPlugin : public PluginImpl
 {
 public:
-	PatchPlugin(URIs&               uris,
+	GraphPlugin(URIs&               uris,
 	            const Raul::URI&    uri,
 	            const Raul::Symbol& symbol,
 	            const std::string&  name)
-		: PluginImpl(uris, Plugin::Patch, uri)
+		: PluginImpl(uris, Plugin::Graph, uri)
 	{}
 
 	BlockImpl* instantiate(BufferFactory&      bufs,
 	                       const Raul::Symbol& symbol,
 	                       bool                polyphonic,
-	                       PatchImpl*          parent,
+	                       GraphImpl*          parent,
 	                       Engine&             engine)
 	{
 		return NULL;
 	}
 
-	const Raul::Symbol symbol() const { return Raul::Symbol("patch"); }
-	const std::string name()    const { return "Ingen Patch"; }
+	const Raul::Symbol symbol() const { return Raul::Symbol("graph"); }
+	const std::string name()    const { return "Ingen Graph"; }
 
 private:
 	const std::string _symbol;
@@ -59,5 +59,5 @@ private:
 } // namespace Server
 } // namespace Ingen
 
-#endif // INGEN_ENGINE_PATCHPLUGIN_HPP
+#endif // INGEN_ENGINE_GRAPHPLUGIN_HPP
 
diff --git a/src/server/InputPort.cpp b/src/server/InputPort.cpp
index fff29f30..e2f97896 100644
--- a/src/server/InputPort.cpp
+++ b/src/server/InputPort.cpp
@@ -25,9 +25,9 @@
 #include "BufferFactory.hpp"
 #include "EdgeImpl.hpp"
 #include "Engine.hpp"
+#include "GraphImpl.hpp"
 #include "InputPort.hpp"
 #include "OutputPort.hpp"
-#include "PatchImpl.hpp"
 #include "ProcessContext.hpp"
 #include "mix.hpp"
 
@@ -50,7 +50,7 @@ InputPort::InputPort(BufferFactory&      bufs,
 {
 	const Ingen::URIs& uris = bufs.uris();
 
-	if (parent->graph_type() != GraphObject::PATCH) {
+	if (parent->graph_type() != GraphObject::GRAPH) {
 		add_property(uris.rdf_type, uris.lv2_InputPort);
 	}
 
@@ -159,7 +159,7 @@ InputPort::remove_edge(ProcessContext& context, const OutputPort* tail)
 uint32_t
 InputPort::max_tail_poly(Context& context) const
 {
-	return parent_block()->parent_patch()->internal_poly_process();
+	return parent_block()->parent_graph()->internal_poly_process();
 }
 
 static void
diff --git a/src/server/InputPort.hpp b/src/server/InputPort.hpp
index 40650415..7a4c7669 100644
--- a/src/server/InputPort.hpp
+++ b/src/server/InputPort.hpp
@@ -36,7 +36,7 @@ class BlockImpl;
 class OutputPort;
 class ProcessContext;
 
-/** An input port on a Block or Patch.
+/** An input port on a Block or Graph.
  *
  * All ports have a Buffer, but the actual contents (data) of that buffer may be
  * set directly to the incoming edge's buffer if there's only one inbound
diff --git a/src/server/InternalPlugin.cpp b/src/server/InternalPlugin.cpp
index 0e15fd9d..39e32580 100644
--- a/src/server/InternalPlugin.cpp
+++ b/src/server/InternalPlugin.cpp
@@ -46,7 +46,7 @@ BlockImpl*
 InternalPlugin::instantiate(BufferFactory&      bufs,
                             const Raul::Symbol& symbol,
                             bool                polyphonic,
-                            PatchImpl*          parent,
+                            GraphImpl*          parent,
                             Engine&             engine)
 {
 	assert(_type == Internal);
diff --git a/src/server/InternalPlugin.hpp b/src/server/InternalPlugin.hpp
index 29753c69..5bd842dd 100644
--- a/src/server/InternalPlugin.hpp
+++ b/src/server/InternalPlugin.hpp
@@ -44,7 +44,7 @@ public:
 	BlockImpl* instantiate(BufferFactory&      bufs,
 	                       const Raul::Symbol& symbol,
 	                       bool                polyphonic,
-	                       PatchImpl*          parent,
+	                       GraphImpl*          parent,
 	                       Engine&             engine);
 
 	const Raul::Symbol symbol() const { return _symbol; }
diff --git a/src/server/JackDriver.cpp b/src/server/JackDriver.cpp
index b950c350..5f1ba1d3 100644
--- a/src/server/JackDriver.cpp
+++ b/src/server/JackDriver.cpp
@@ -35,8 +35,8 @@
 #include "Buffer.hpp"
 #include "DuplexPort.hpp"
 #include "Engine.hpp"
+#include "GraphImpl.hpp"
 #include "JackDriver.hpp"
-#include "PatchImpl.hpp"
 #include "PortImpl.hpp"
 #include "ThreadManager.hpp"
 #include "util.hpp"
@@ -182,7 +182,7 @@ EnginePort*
 JackDriver::get_port(const Raul::Path& path)
 {
 	for (Ports::iterator i = _ports.begin(); i != _ports.end(); ++i) {
-		if (i->patch_port()->path() == path) {
+		if (i->graph_port()->path() == path) {
 			return &*i;
 		}
 	}
@@ -207,10 +207,10 @@ JackDriver::register_port(EnginePort& port)
 {
 	jack_port_t* jack_port = jack_port_register(
 		_client,
-		port.patch_port()->path().substr(1).c_str(),
-		(port.patch_port()->is_a(PortType::AUDIO)
+		port.graph_port()->path().substr(1).c_str(),
+		(port.graph_port()->is_a(PortType::AUDIO)
 		 ? JACK_DEFAULT_AUDIO_TYPE : JACK_DEFAULT_MIDI_TYPE),
-		(port.patch_port()->is_input()
+		(port.graph_port()->is_input()
 		 ? JackPortIsInput : JackPortIsOutput),
 		0);
 
@@ -241,16 +241,16 @@ JackDriver::rename_port(const Raul::Path& old_path,
 }
 
 EnginePort*
-JackDriver::create_port(DuplexPort* patch_port)
+JackDriver::create_port(DuplexPort* graph_port)
 {
-	if (patch_port &&
-	    (patch_port->is_a(PortType::AUDIO) ||
-	     (patch_port->is_a(PortType::ATOM) &&
-	      patch_port->buffer_type() == _engine.world()->uris().atom_Sequence))) {
-		EnginePort* eport = new EnginePort(patch_port);
+	if (graph_port &&
+	    (graph_port->is_a(PortType::AUDIO) ||
+	     (graph_port->is_a(PortType::ATOM) &&
+	      graph_port->buffer_type() == _engine.world()->uris().atom_Sequence))) {
+		EnginePort* eport = new EnginePort(graph_port);
 		register_port(*eport);
-		patch_port->setup_buffers(*_engine.buffer_factory(),
-		                          patch_port->poly(),
+		graph_port->setup_buffers(*_engine.buffer_factory(),
+		                          graph_port->poly(),
 		                          false);
 		return eport;
 	} else {
@@ -263,33 +263,33 @@ JackDriver::pre_process_port(ProcessContext& context, EnginePort* port)
 {
 	const SampleCount nframes    = context.nframes();
 	jack_port_t*      jack_port  = (jack_port_t*)port->handle();
-	PortImpl*         patch_port = port->patch_port();
+	PortImpl*         graph_port = port->graph_port();
 	void*             buffer     = jack_port_get_buffer(jack_port, nframes);
 
 	port->set_buffer(buffer);
 
-	if (!patch_port->is_input()) {
-		patch_port->buffer(0)->clear();
+	if (!graph_port->is_input()) {
+		graph_port->buffer(0)->clear();
 		return;
 	}
 
-	if (patch_port->is_a(PortType::AUDIO)) {
-		Buffer* patch_buf = patch_port->buffer(0).get();
-		memcpy(patch_buf->samples(), buffer, nframes * sizeof(float));
+	if (graph_port->is_a(PortType::AUDIO)) {
+		Buffer* graph_buf = graph_port->buffer(0).get();
+		memcpy(graph_buf->samples(), buffer, nframes * sizeof(float));
 
-	} else if (patch_port->buffer_type() == patch_port->bufs().uris().atom_Sequence) {
-		Buffer* patch_buf = (Buffer*)patch_port->buffer(0).get();
+	} else if (graph_port->buffer_type() == graph_port->bufs().uris().atom_Sequence) {
+		Buffer* graph_buf = (Buffer*)graph_port->buffer(0).get();
 
 		const jack_nframes_t event_count = jack_midi_get_event_count(buffer);
 
-		patch_buf->prepare_write(context);
+		graph_buf->prepare_write(context);
 
-		// Copy events from Jack port buffer into patch port buffer
+		// Copy events from Jack port buffer into graph port buffer
 		for (jack_nframes_t i = 0; i < event_count; ++i) {
 			jack_midi_event_t ev;
 			jack_midi_event_get(&ev, buffer, i);
 
-			if (!patch_buf->append_event(
+			if (!graph_buf->append_event(
 				    ev.time, ev.size, _midi_event_type, ev.buffer)) {
 				_engine.log().warn("Failed to write to MIDI buffer, events lost!\n");
 			}
@@ -302,10 +302,10 @@ JackDriver::post_process_port(ProcessContext& context, EnginePort* port)
 {
 	const SampleCount nframes    = context.nframes();
 	jack_port_t*      jack_port  = (jack_port_t*)port->handle();
-	PortImpl*         patch_port = port->patch_port();
+	PortImpl*         graph_port = port->graph_port();
 	void*             buffer     = port->buffer();
 
-	if (patch_port->is_input()) {
+	if (graph_port->is_input()) {
 		return;
 	}
 
@@ -315,16 +315,16 @@ JackDriver::post_process_port(ProcessContext& context, EnginePort* port)
 		port->set_buffer(buffer);
 	}
 
-	patch_port->post_process(context);
-	Buffer* const patch_buf = patch_port->buffer(0).get();
-	if (patch_port->is_a(PortType::AUDIO)) {
-		memcpy(buffer, patch_buf->samples(), nframes * sizeof(Sample));
-	} else if (patch_port->buffer_type() == patch_port->bufs().uris().atom_Sequence) {
+	graph_port->post_process(context);
+	Buffer* const graph_buf = graph_port->buffer(0).get();
+	if (graph_port->is_a(PortType::AUDIO)) {
+		memcpy(buffer, graph_buf->samples(), nframes * sizeof(Sample));
+	} else if (graph_port->buffer_type() == graph_port->bufs().uris().atom_Sequence) {
 		jack_midi_clear_buffer(buffer);
-		LV2_Atom_Sequence* seq = (LV2_Atom_Sequence*)patch_buf->atom();
+		LV2_Atom_Sequence* seq = (LV2_Atom_Sequence*)graph_buf->atom();
 		LV2_ATOM_SEQUENCE_FOREACH(seq, ev) {
 			const uint8_t* buf = (const uint8_t*)LV2_ATOM_BODY(&ev->body);
-			if (ev->body.type == patch_port->bufs().uris().midi_MidiEvent) {
+			if (ev->body.type == graph_port->bufs().uris().midi_MidiEvent) {
 				jack_midi_event_write(buffer, ev->time.frames, buf, ev->body.size);
 			}
 		}
@@ -388,9 +388,9 @@ JackDriver::_shutdown_cb()
 int
 JackDriver::_block_length_cb(jack_nframes_t nframes)
 {
-	if (_engine.root_patch()) {
+	if (_engine.root_graph()) {
 		_block_length = nframes;
-		_engine.root_patch()->set_buffer_size(
+		_engine.root_graph()->set_buffer_size(
 			_engine.process_context(), *_engine.buffer_factory(), PortType::AUDIO,
 			_engine.buffer_factory()->audio_buffer_size(nframes));
 	}
@@ -409,7 +409,7 @@ JackDriver::_session_cb(jack_session_event_t* event)
 
 	SharedPtr<Serialisation::Serialiser> serialiser = _engine.world()->serialiser();
 	if (serialiser) {
-		SharedPtr<GraphObject> root(_engine.root_patch(), NullDeleter<GraphObject>);
+		SharedPtr<GraphObject> root(_engine.root_graph(), NullDeleter<GraphObject>);
 		serialiser->write_bundle(root, string("file://") + event->session_dir);
 	}
 
diff --git a/src/server/JackDriver.hpp b/src/server/JackDriver.hpp
index c9bda939..8ea84fd6 100644
--- a/src/server/JackDriver.hpp
+++ b/src/server/JackDriver.hpp
@@ -38,16 +38,16 @@ namespace Raul { class Path; }
 namespace Ingen {
 namespace Server {
 
-class Engine;
-class PatchImpl;
-class PortImpl;
 class DuplexPort;
+class Engine;
+class GraphImpl;
 class JackDriver;
+class PortImpl;
 
 /** The Jack Driver.
  *
  * The process callback here drives the entire audio thread by "pulling"
- * events from queues, processing them, running the patches, and passing
+ * events from queues, processing them, running the graphes, and passing
  * events along to the PostProcessor.
  *
  * \ingroup engine
@@ -67,7 +67,7 @@ public:
 	void enable();
 	void disable();
 
-	EnginePort* create_port(DuplexPort* patch_port);
+	EnginePort* create_port(DuplexPort* graph_port);
 	EnginePort* get_port(const Raul::Path& path);
 
 	void rename_port(const Raul::Path& old_path, const Raul::Path& new_path);
diff --git a/src/server/LV2Block.cpp b/src/server/LV2Block.cpp
index d26f7417..e121f270 100644
--- a/src/server/LV2Block.cpp
+++ b/src/server/LV2Block.cpp
@@ -32,11 +32,11 @@
 #include "Buffer.hpp"
 #include "Driver.hpp"
 #include "Engine.hpp"
+#include "GraphImpl.hpp"
 #include "InputPort.hpp"
 #include "LV2Block.hpp"
 #include "LV2Plugin.hpp"
 #include "OutputPort.hpp"
-#include "PatchImpl.hpp"
 #include "ProcessContext.hpp"
 
 using namespace std;
@@ -52,7 +52,7 @@ namespace Server {
 LV2Block::LV2Block(LV2Plugin*          plugin,
                    const Raul::Symbol& symbol,
                    bool                polyphonic,
-                   PatchImpl*          parent,
+                   GraphImpl*          parent,
                    SampleRate          srate)
 : BlockImpl(plugin, symbol, polyphonic, parent, srate)
 	, _lv2_plugin(plugin)
@@ -78,7 +78,7 @@ LV2Block::make_instance(URIs&      uris,
 		_lv2_plugin->lilv_plugin(), rate, _features->array());
 
 	if (!inst) {
-		parent_patch()->engine().log().error(
+		parent_graph()->engine().log().error(
 			Raul::fmt("Failed to instantiate <%1%>\n")
 			% _lv2_plugin->uri().c_str());
 		return SharedPtr<LilvInstance>();
@@ -119,7 +119,7 @@ LV2Block::make_instance(URIs&      uris,
 				} else if (type == _uris.lv2_CVPort) {
 					port->set_type(PortType::CV, 0);
 				} else {
-					parent_patch()->engine().log().error(
+					parent_graph()->engine().log().error(
 						Raul::fmt("%1% auto-morphed to unknown type %2%\n")
 						% port->path().c_str() % type);
 					return SharedPtr<LilvInstance>();
@@ -304,7 +304,7 @@ LV2Block::instantiate(BufferFactory& bufs)
 		}
 
 		if (port_type == PortType::UNKNOWN || direction == UNKNOWN) {
-			parent_patch()->engine().log().error(
+			parent_graph()->engine().log().error(
 				Raul::fmt("<%1%> port %2% has unknown type or direction\n")
 				% _lv2_plugin->uri().c_str() % port_sym.c_str());
 			ret = false;
@@ -422,7 +422,7 @@ LV2Block::work(uint32_t size, const void* data)
 	if (_worker_iface) {
 		LV2_Handle inst = lilv_instance_get_handle(instance(0));
 		if (_worker_iface->work(inst, work_respond, this, size, data)) {
-			parent_patch()->engine().log().error(
+			parent_graph()->engine().log().error(
 				Raul::fmt("Error calling %1% work method\n") % _path);
 		}
 	}
diff --git a/src/server/LV2Block.hpp b/src/server/LV2Block.hpp
index 3746b201..2e45d350 100644
--- a/src/server/LV2Block.hpp
+++ b/src/server/LV2Block.hpp
@@ -39,10 +39,10 @@ class LV2Block : public BlockImpl
 {
 public:
 	LV2Block(LV2Plugin*          plugin,
-	        const Raul::Symbol& symbol,
-	        bool                polyphonic,
-	        PatchImpl*          parent,
-	        SampleRate          srate);
+	         const Raul::Symbol& symbol,
+	         bool                polyphonic,
+	         GraphImpl*          parent,
+	         SampleRate          srate);
 
 	~LV2Block();
 
diff --git a/src/server/LV2Plugin.cpp b/src/server/LV2Plugin.cpp
index 0febfc7d..cc0aee4c 100644
--- a/src/server/LV2Plugin.cpp
+++ b/src/server/LV2Plugin.cpp
@@ -60,7 +60,7 @@ BlockImpl*
 LV2Plugin::instantiate(BufferFactory&      bufs,
                        const Raul::Symbol& symbol,
                        bool                polyphonic,
-                       PatchImpl*          parent,
+                       GraphImpl*          parent,
                        Engine&             engine)
 {
 	LV2Block* b = new LV2Block(
diff --git a/src/server/LV2Plugin.hpp b/src/server/LV2Plugin.hpp
index ed26b4ae..bec1b588 100644
--- a/src/server/LV2Plugin.hpp
+++ b/src/server/LV2Plugin.hpp
@@ -29,7 +29,7 @@
 namespace Ingen {
 namespace Server {
 
-class PatchImpl;
+class GraphImpl;
 class BlockImpl;
 
 /** Implementation of an LV2 plugin (loaded shared library).
@@ -42,7 +42,7 @@ public:
 	BlockImpl* instantiate(BufferFactory&      bufs,
 	                       const Raul::Symbol& symbol,
 	                       bool                polyphonic,
-	                       PatchImpl*          parent,
+	                       GraphImpl*          parent,
 	                       Engine&             engine);
 
 	const Raul::Symbol symbol() const;
diff --git a/src/server/OutputPort.cpp b/src/server/OutputPort.cpp
index 1fa53451..48f7eb22 100644
--- a/src/server/OutputPort.cpp
+++ b/src/server/OutputPort.cpp
@@ -38,7 +38,7 @@ OutputPort::OutputPort(BufferFactory&      bufs,
                        size_t              buffer_size)
 	: PortImpl(bufs, parent, symbol, index, poly, type, buffer_type, value, buffer_size)
 {
-	if (parent->graph_type() != GraphObject::PATCH) {
+	if (parent->graph_type() != GraphObject::GRAPH) {
 		add_property(bufs.uris().rdf_type, bufs.uris().lv2_OutputPort);
 	}
 
diff --git a/src/server/PluginImpl.hpp b/src/server/PluginImpl.hpp
index 624b3f6d..342225ef 100644
--- a/src/server/PluginImpl.hpp
+++ b/src/server/PluginImpl.hpp
@@ -35,7 +35,7 @@ namespace Server {
 class BlockImpl;
 class BufferFactory;
 class Engine;
-class PatchImpl;
+class GraphImpl;
 
 /** Implementation of a plugin (internal code, or a loaded shared library).
  *
@@ -55,8 +55,8 @@ public:
 	virtual BlockImpl* instantiate(BufferFactory&      bufs,
 	                               const Raul::Symbol& symbol,
 	                               bool                polyphonic,
-	                               PatchImpl*          parent,
-	                               Engine&            engine) = 0;
+	                               GraphImpl*          parent,
+	                               Engine&             engine) = 0;
 
 	virtual const Raul::Symbol symbol() const = 0;
 
diff --git a/src/server/Worker.cpp b/src/server/Worker.cpp
index 6a39cba8..9fbc4825 100644
--- a/src/server/Worker.cpp
+++ b/src/server/Worker.cpp
@@ -20,8 +20,8 @@
 
 #include "Driver.hpp"
 #include "Engine.hpp"
+#include "GraphImpl.hpp"
 #include "LV2Block.hpp"
-#include "PatchImpl.hpp"
 #include "Worker.hpp"
 
 namespace Ingen {
@@ -40,7 +40,7 @@ schedule(LV2_Worker_Schedule_Handle handle,
          const void*                data)
 {
 	LV2Block* block  = (LV2Block*)handle;
-	Engine&   engine = block->parent_patch()->engine();
+	Engine&   engine = block->parent_graph()->engine();
 	Worker*   worker = engine.worker();
 
 	return worker->request(block, size, data);
@@ -51,7 +51,7 @@ Worker::request(LV2Block*   block,
                 uint32_t    size,
                 const void* data)
 {
-	Engine& engine = block->parent_patch()->engine();
+	Engine& engine = block->parent_graph()->engine();
 	if (_requests.write_space() < sizeof(MessageHeader) + size) {
 		engine.log().error("Work request ring overflow\n");
 		return LV2_WORKER_ERR_NO_SPACE;
diff --git a/src/server/events.hpp b/src/server/events.hpp
index 95f3d35f..24ac8593 100644
--- a/src/server/events.hpp
+++ b/src/server/events.hpp
@@ -19,7 +19,7 @@
 
 #include "events/Connect.hpp"
 #include "events/CreateBlock.hpp"
-#include "events/CreatePatch.hpp"
+#include "events/CreateGraph.hpp"
 #include "events/CreatePort.hpp"
 #include "events/Delete.hpp"
 #include "events/Delta.hpp"
diff --git a/src/server/events/Connect.cpp b/src/server/events/Connect.cpp
index db8e044f..eeaa1904 100644
--- a/src/server/events/Connect.cpp
+++ b/src/server/events/Connect.cpp
@@ -24,9 +24,9 @@
 #include "Connect.hpp"
 #include "EdgeImpl.hpp"
 #include "Engine.hpp"
+#include "GraphImpl.hpp"
 #include "InputPort.hpp"
 #include "OutputPort.hpp"
-#include "PatchImpl.hpp"
 #include "PortImpl.hpp"
 #include "types.hpp"
 
@@ -43,9 +43,9 @@ Connect::Connect(Engine&              engine,
 	: Event(engine, client, id, timestamp)
 	, _tail_path(tail_path)
 	, _head_path(head_path)
-	, _patch(NULL)
+	, _graph(NULL)
 	, _head(NULL)
-	, _compiled_patch(NULL)
+	, _compiled_graph(NULL)
 	, _buffers(NULL)
 {}
 
@@ -86,23 +86,23 @@ Connect::pre_process()
 		return Event::pre_process_done(TYPE_MISMATCH, _head_path);
 	}
 
-	if (tail_block->parent_patch() != head_block->parent_patch()) {
-		// Edge to a patch port from inside the patch
+	if (tail_block->parent_graph() != head_block->parent_graph()) {
+		// Edge to a graph port from inside the graph
 		assert(tail_block->parent() == head_block || head_block->parent() == tail_block);
 		if (tail_block->parent() == head_block) {
-			_patch = dynamic_cast<PatchImpl*>(head_block);
+			_graph = dynamic_cast<GraphImpl*>(head_block);
 		} else {
-			_patch = dynamic_cast<PatchImpl*>(tail_block);
+			_graph = dynamic_cast<GraphImpl*>(tail_block);
 		}
-	} else if (tail_block == head_block && dynamic_cast<PatchImpl*>(tail_block)) {
-		// Edge from a patch input to a patch output (pass through)
-		_patch = dynamic_cast<PatchImpl*>(tail_block);
+	} else if (tail_block == head_block && dynamic_cast<GraphImpl*>(tail_block)) {
+		// Edge from a graph input to a graph output (pass through)
+		_graph = dynamic_cast<GraphImpl*>(tail_block);
 	} else {
 		// Normal edge between blocks with the same parent
-		_patch = tail_block->parent_patch();
+		_graph = tail_block->parent_graph();
 	}
 
-	if (_patch->has_edge(tail_output, _head)) {
+	if (_graph->has_edge(tail_output, _head)) {
 		return Event::pre_process_done(EXISTS, _head_path);
 	}
 
@@ -113,8 +113,8 @@ Connect::pre_process()
 	{
 		Glib::RWLock::ReaderLock wlock(_engine.store()->lock());
 
-		/* Need to be careful about patch port edges here and adding a
-		   block's parent as a dependant/provider, or adding a patch as its own
+		/* Need to be careful about graph port edges here and adding a
+		   block's parent as a dependant/provider, or adding a graph as its own
 		   provider...
 		*/
 		if (tail_block != head_block && tail_block->parent() == head_block->parent()) {
@@ -122,7 +122,7 @@ Connect::pre_process()
 			tail_block->dependants().push_back(head_block);
 		}
 
-		_patch->add_edge(_edge);
+		_graph->add_edge(_edge);
 		_head->increment_num_edges();
 	}
 
@@ -132,8 +132,8 @@ Connect::pre_process()
 	                   _head->poly(),
 	                   false);
 
-	if (_patch->enabled()) {
-		_compiled_patch = _patch->compile();
+	if (_graph->enabled()) {
+		_compiled_graph = _graph->compile();
 	}
 
 	return Event::pre_process_done(SUCCESS);
@@ -146,8 +146,8 @@ Connect::execute(ProcessContext& context)
 		_head->add_edge(context, _edge.get());
 		_engine.maid()->dispose(_head->set_buffers(context, _buffers));
 		_head->connect_buffers();
-		_engine.maid()->dispose(_patch->compiled_patch());
-		_patch->compiled_patch(_compiled_patch);
+		_engine.maid()->dispose(_graph->compiled_graph());
+		_graph->compiled_graph(_compiled_graph);
 	}
 }
 
diff --git a/src/server/events/Connect.hpp b/src/server/events/Connect.hpp
index 8d75d2da..445ee80e 100644
--- a/src/server/events/Connect.hpp
+++ b/src/server/events/Connect.hpp
@@ -30,11 +30,11 @@ template <typename T> class Array;
 namespace Ingen {
 namespace Server {
 
-class CompiledPatch;
+class CompiledGraph;
 class EdgeImpl;
 class InputPort;
 class OutputPort;
-class PatchImpl;
+class GraphImpl;
 
 namespace Events {
 
@@ -59,9 +59,9 @@ public:
 private:
 	const Raul::Path        _tail_path;
 	const Raul::Path        _head_path;
-	PatchImpl*              _patch;
+	GraphImpl*              _graph;
 	InputPort*              _head;
-	CompiledPatch*          _compiled_patch;
+	CompiledGraph*          _compiled_graph;
 	SharedPtr<EdgeImpl>     _edge;
 	Raul::Array<BufferRef>* _buffers;
 };
diff --git a/src/server/events/CreateBlock.cpp b/src/server/events/CreateBlock.cpp
index 73ff7ba2..bc234b97 100644
--- a/src/server/events/CreateBlock.cpp
+++ b/src/server/events/CreateBlock.cpp
@@ -24,7 +24,7 @@
 #include "Broadcaster.hpp"
 #include "CreateBlock.hpp"
 #include "Engine.hpp"
-#include "PatchImpl.hpp"
+#include "GraphImpl.hpp"
 #include "PluginImpl.hpp"
 #include "PortImpl.hpp"
 
@@ -41,9 +41,9 @@ CreateBlock::CreateBlock(Engine&                     engine,
 	: Event(engine, client, id, timestamp)
 	, _path(path)
 	, _properties(properties)
-	, _patch(NULL)
+	, _graph(NULL)
 	, _block(NULL)
-	, _compiled_patch(NULL)
+	, _compiled_graph(NULL)
 {}
 
 bool
@@ -69,8 +69,8 @@ CreateBlock::pre_process()
 		return Event::pre_process_done(EXISTS, _path);
 	}
 
-	_patch = dynamic_cast<PatchImpl*>(_engine.store()->get(_path.parent()));
-	if (!_patch) {
+	_graph = dynamic_cast<GraphImpl*>(_engine.store()->get(_path.parent()));
+	if (!_graph) {
 		return Event::pre_process_done(PARENT_NOT_FOUND, _path.parent());
 	}
 
@@ -89,7 +89,7 @@ CreateBlock::pre_process()
 	if (!(_block = plugin->instantiate(*_engine.buffer_factory(),
 	                                  Raul::Symbol(_path.symbol()),
 	                                  polyphonic,
-	                                  _patch,
+	                                  _graph,
 	                                  _engine))) {
 		return Event::pre_process_done(CREATION_FAILED, _path);
 	}
@@ -97,15 +97,15 @@ CreateBlock::pre_process()
 	_block->properties().insert(_properties.begin(), _properties.end());
 	_block->activate(*_engine.buffer_factory());
 
-	// Add block to the store and the patch's pre-processor only block list
-	_patch->add_block(*_block);
+	// Add block to the store and the graph's pre-processor only block list
+	_graph->add_block(*_block);
 	_engine.store()->add(_block);
 
-	/* Compile patch with new block added for insertion in audio thread
+	/* Compile graph with new block added for insertion in audio thread
 	   TODO: Since the block is not connected at this point, a full compilation
 	   could be avoided and the block simply appended. */
-	if (_patch->enabled()) {
-		_compiled_patch = _patch->compile();
+	if (_graph->enabled()) {
+		_compiled_graph = _graph->compile();
 	}
 
 	_update.push_back(make_pair(_block->uri(), _block->properties()));
@@ -124,8 +124,8 @@ void
 CreateBlock::execute(ProcessContext& context)
 {
 	if (_block) {
-		_engine.maid()->dispose(_patch->compiled_patch());
-		_patch->compiled_patch(_compiled_patch);
+		_engine.maid()->dispose(_graph->compiled_graph());
+		_graph->compiled_graph(_compiled_graph);
 	}
 }
 
diff --git a/src/server/events/CreateBlock.hpp b/src/server/events/CreateBlock.hpp
index ea3c4b5c..da444b1f 100644
--- a/src/server/events/CreateBlock.hpp
+++ b/src/server/events/CreateBlock.hpp
@@ -28,12 +28,12 @@ namespace Ingen {
 namespace Server {
 
 class BlockImpl;
-class CompiledPatch;
-class PatchImpl;
+class CompiledGraph;
+class GraphImpl;
 
 namespace Events {
 
-/** An event to load a Block and insert it into a Patch.
+/** An event to load a Block and insert it into a Graph.
  *
  * \ingroup engine
  */
@@ -58,9 +58,9 @@ private:
 	Raul::Path           _path;
 	Resource::Properties _properties;
 	Update               _update;
-	PatchImpl*           _patch;
+	GraphImpl*           _graph;
 	BlockImpl*           _block;
-	CompiledPatch*       _compiled_patch;
+	CompiledGraph*       _compiled_graph;
 };
 
 } // namespace Events
diff --git a/src/server/events/CreatePatch.cpp b/src/server/events/CreateGraph.cpp
index e9adc547..bfe08043 100644
--- a/src/server/events/CreatePatch.cpp
+++ b/src/server/events/CreateGraph.cpp
@@ -19,17 +19,17 @@
 #include "raul/Maid.hpp"
 #include "raul/Path.hpp"
 
-#include "events/CreatePatch.hpp"
 #include "Broadcaster.hpp"
 #include "Driver.hpp"
 #include "Engine.hpp"
-#include "PatchImpl.hpp"
+#include "GraphImpl.hpp"
+#include "events/CreateGraph.hpp"
 
 namespace Ingen {
 namespace Server {
 namespace Events {
 
-CreatePatch::CreatePatch(Engine&                     engine,
+CreateGraph::CreateGraph(Engine&                     engine,
                          SharedPtr<Interface>        client,
                          int32_t                     id,
                          SampleCount                 timestamp,
@@ -38,20 +38,20 @@ CreatePatch::CreatePatch(Engine&                     engine,
 	: Event(engine, client, id, timestamp)
 	, _path(path)
 	, _properties(properties)
-	, _patch(NULL)
+	, _graph(NULL)
 	, _parent(NULL)
-	, _compiled_patch(NULL)
+	, _compiled_graph(NULL)
 {
 }
 
 bool
-CreatePatch::pre_process()
+CreateGraph::pre_process()
 {
 	if (_path.is_root() || _engine.store()->get(_path)) {
 		return Event::pre_process_done(EXISTS, _path);
 	}
 
-	_parent = dynamic_cast<PatchImpl*>(_engine.store()->get(_path.parent()));
+	_parent = dynamic_cast<GraphImpl*>(_engine.store()->get(_path.parent()));
 	if (!_parent) {
 		return Event::pre_process_done(PARENT_NOT_FOUND, _path.parent());
 	}
@@ -76,42 +76,42 @@ CreatePatch::pre_process()
 	}
 
 	const Raul::Symbol symbol((_path.is_root()) ? "root" : _path.symbol());
-	_patch = new PatchImpl(_engine, symbol, ext_poly, _parent,
+	_graph = new GraphImpl(_engine, symbol, ext_poly, _parent,
 	                       _engine.driver()->sample_rate(), int_poly);
-	_patch->properties().insert(_properties.begin(), _properties.end());
-	_patch->add_property(uris.rdf_type, uris.ingen_Patch);
-	_patch->add_property(uris.rdf_type,
+	_graph->properties().insert(_properties.begin(), _properties.end());
+	_graph->add_property(uris.rdf_type, uris.ingen_Graph);
+	_graph->add_property(uris.rdf_type,
 	                     Resource::Property(uris.ingen_Block, Resource::EXTERNAL));
 
-	_parent->add_block(*_patch);
+	_parent->add_block(*_graph);
 	if (_parent->enabled()) {
-		_patch->enable();
-		_compiled_patch = _parent->compile();
+		_graph->enable();
+		_compiled_graph = _parent->compile();
 	}
 
-	_patch->activate(*_engine.buffer_factory());
+	_graph->activate(*_engine.buffer_factory());
 
 	// Insert into Store
-	_engine.store()->add(_patch);
+	_engine.store()->add(_graph);
 
-	_update = _patch->properties();
+	_update = _graph->properties();
 
 	return Event::pre_process_done(SUCCESS);
 }
 
 void
-CreatePatch::execute(ProcessContext& context)
+CreateGraph::execute(ProcessContext& context)
 {
-	if (_patch) {
+	if (_graph) {
 		assert(_parent);
 		assert(!_path.is_root());
-		_engine.maid()->dispose(_parent->compiled_patch());
-		_parent->compiled_patch(_compiled_patch);
+		_engine.maid()->dispose(_parent->compiled_graph());
+		_parent->compiled_graph(_compiled_graph);
 	}
 }
 
 void
-CreatePatch::post_process()
+CreateGraph::post_process()
 {
 	if (!respond()) {
 		_engine.broadcaster()->put(GraphObject::path_to_uri(_path), _update);
diff --git a/src/server/events/CreatePatch.hpp b/src/server/events/CreateGraph.hpp
index be19d54e..0f6a95dd 100644
--- a/src/server/events/CreatePatch.hpp
+++ b/src/server/events/CreateGraph.hpp
@@ -14,8 +14,8 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef INGEN_EVENTS_CREATEPATCH_HPP
-#define INGEN_EVENTS_CREATEPATCH_HPP
+#ifndef INGEN_EVENTS_CREATEGRAPH_HPP
+#define INGEN_EVENTS_CREATEGRAPH_HPP
 
 #include "Event.hpp"
 #include "ingen/Resource.hpp"
@@ -23,19 +23,19 @@
 namespace Ingen {
 namespace Server {
 
-class PatchImpl;
-class CompiledPatch;
+class GraphImpl;
+class CompiledGraph;
 
 namespace Events {
 
-/** Creates a new Patch.
+/** Creates a new Graph.
  *
  * \ingroup engine
  */
-class CreatePatch : public Event
+class CreateGraph : public Event
 {
 public:
-	CreatePatch(Engine&                     engine,
+	CreateGraph(Engine&                     engine,
 	            SharedPtr<Interface>        client,
 	            int32_t                     id,
 	            SampleCount                 timestamp,
@@ -50,13 +50,13 @@ private:
 	const Raul::Path     _path;
 	Resource::Properties _properties;
 	Resource::Properties _update;
-	PatchImpl*           _patch;
-	PatchImpl*           _parent;
-	CompiledPatch*       _compiled_patch;
+	GraphImpl*           _graph;
+	GraphImpl*           _parent;
+	CompiledGraph*       _compiled_graph;
 };
 
 } // namespace Events
 } // namespace Server
 } // namespace Ingen
 
-#endif // INGEN_EVENTS_CREATEPATCH_HPP
+#endif // INGEN_EVENTS_CREATEGRAPH_HPP
diff --git a/src/server/events/CreatePort.cpp b/src/server/events/CreatePort.cpp
index 49ceed95..a32faaee 100644
--- a/src/server/events/CreatePort.cpp
+++ b/src/server/events/CreatePort.cpp
@@ -29,7 +29,7 @@
 #include "Driver.hpp"
 #include "DuplexPort.hpp"
 #include "Engine.hpp"
-#include "PatchImpl.hpp"
+#include "GraphImpl.hpp"
 #include "PortImpl.hpp"
 
 namespace Ingen {
@@ -47,8 +47,8 @@ CreatePort::CreatePort(Engine&                     engine,
 	, _path(path)
 	, _port_type(PortType::UNKNOWN)
 	, _buf_type(0)
-	, _patch(NULL)
-	, _patch_port(NULL)
+	, _graph(NULL)
+	, _graph_port(NULL)
 	, _ports_array(NULL)
 	, _old_ports_array(NULL)
 	, _engine_port(NULL)
@@ -102,7 +102,7 @@ CreatePort::pre_process()
 		return Event::pre_process_done(PARENT_NOT_FOUND, _path.parent());
 	}
 
-	if (!(_patch = dynamic_cast<PatchImpl*>(parent))) {
+	if (!(_graph = dynamic_cast<GraphImpl*>(parent))) {
 		return Event::pre_process_done(INVALID_PARENT_PATH, _path.parent());
 	}
 
@@ -110,7 +110,7 @@ CreatePort::pre_process()
 	const BufferFactory& buffer_factory = *_engine.buffer_factory();
 
 	const uint32_t buf_size    = buffer_factory.default_size(_buf_type);
-	const int32_t  old_n_ports = _patch->num_ports_non_rt();
+	const int32_t  old_n_ports = _graph->num_ports_non_rt();
 
 	typedef Resource::Properties::const_iterator PropIter;
 
@@ -130,34 +130,34 @@ CreatePort::pre_process()
 	                         poly_i->second.type() == uris.forge.Bool &&
 	                         poly_i->second.get_bool());
 
-	if (!(_patch_port = _patch->create_port(
+	if (!(_graph_port = _graph->create_port(
 		      *_engine.buffer_factory(), Raul::Symbol(_path.symbol()),
 		      _port_type, _buf_type, buf_size, _is_output, polyphonic))) {
 		return Event::pre_process_done(CREATION_FAILED, _path);
 	}
 
-	_patch_port->properties().insert(_properties.begin(), _properties.end());
+	_graph_port->properties().insert(_properties.begin(), _properties.end());
 
-	_engine.store()->add(_patch_port);
+	_engine.store()->add(_graph_port);
 	if (_is_output) {
-		_patch->add_output(*_patch_port);
+		_graph->add_output(*_graph_port);
 	} else {
-		_patch->add_input(*_patch_port);
+		_graph->add_input(*_graph_port);
 	}
 
-	if (!_patch->parent()) {
+	if (!_graph->parent()) {
 		_engine_port = _engine.driver()->create_port(
-			dynamic_cast<DuplexPort*>(_patch_port));
+			dynamic_cast<DuplexPort*>(_graph_port));
 	}
 
 	_ports_array = new Raul::Array<PortImpl*>(old_n_ports + 1, NULL);
-	_update      = _patch_port->properties();
+	_update      = _graph_port->properties();
 
-	assert(_patch_port->index() == (uint32_t)index_i->second.get_int32());
-	assert(_patch->num_ports_non_rt() == (uint32_t)old_n_ports + 1);
-	assert(_patch_port->index() == (uint32_t)old_n_ports);
-	assert(_ports_array->size() == _patch->num_ports_non_rt());
-	assert(_patch_port->index() < _ports_array->size());
+	assert(_graph_port->index() == (uint32_t)index_i->second.get_int32());
+	assert(_graph->num_ports_non_rt() == (uint32_t)old_n_ports + 1);
+	assert(_graph_port->index() == (uint32_t)old_n_ports);
+	assert(_ports_array->size() == _graph->num_ports_non_rt());
+	assert(_graph_port->index() < _ports_array->size());
 	return Event::pre_process_done(SUCCESS);
 }
 
@@ -165,15 +165,15 @@ void
 CreatePort::execute(ProcessContext& context)
 {
 	if (!_status) {
-		_old_ports_array = _patch->external_ports();
+		_old_ports_array = _graph->external_ports();
 		if (_old_ports_array) {
 			for (uint32_t i = 0; i < _old_ports_array->size(); ++i) {
 				(*_ports_array)[i] = (*_old_ports_array)[i];
 			}
 		}
-		assert(!(*_ports_array)[_patch_port->index()]);
-		(*_ports_array)[_patch_port->index()] = _patch_port;
-		_patch->external_ports(_ports_array);
+		assert(!(*_ports_array)[_graph_port->index()]);
+		(*_ports_array)[_graph_port->index()] = _graph_port;
+		_graph->external_ports(_ports_array);
 
 		if (_engine_port) {
 			_engine.driver()->add_port(context, _engine_port);
diff --git a/src/server/events/CreatePort.hpp b/src/server/events/CreatePort.hpp
index c8e4c695..d35b58af 100644
--- a/src/server/events/CreatePort.hpp
+++ b/src/server/events/CreatePort.hpp
@@ -30,12 +30,12 @@ namespace Server {
 
 class DuplexPort;
 class EnginePort;
-class PatchImpl;
+class GraphImpl;
 class PortImpl;
 
 namespace Events {
 
-/** An event to add a Port to a Patch.
+/** An event to add a Port to a Graph.
  *
  * \ingroup engine
  */
@@ -58,9 +58,9 @@ private:
 	Raul::Path              _path;
 	PortType                _port_type;
 	LV2_URID                _buf_type;
-	PatchImpl*              _patch;
-	DuplexPort*             _patch_port;
-	Raul::Array<PortImpl*>* _ports_array; ///< New external port array for Patch
+	GraphImpl*              _graph;
+	DuplexPort*             _graph_port;
+	Raul::Array<PortImpl*>* _ports_array; ///< New external port array for Graph
 	Raul::Array<PortImpl*>* _old_ports_array;
 	EnginePort*             _engine_port; ///< Driver port if on the root
 	Resource::Properties    _properties;
diff --git a/src/server/events/Delete.cpp b/src/server/events/Delete.cpp
index dbda331c..a6207ba1 100644
--- a/src/server/events/Delete.cpp
+++ b/src/server/events/Delete.cpp
@@ -26,7 +26,7 @@
 #include "Driver.hpp"
 #include "Engine.hpp"
 #include "EnginePort.hpp"
-#include "PatchImpl.hpp"
+#include "GraphImpl.hpp"
 #include "PluginImpl.hpp"
 #include "PortImpl.hpp"
 
@@ -43,7 +43,7 @@ Delete::Delete(Engine&              engine,
 	, _uri(uri)
 	, _engine_port(NULL)
 	, _ports_array(NULL)
-	, _compiled_patch(NULL)
+	, _compiled_graph(NULL)
 	, _disconnect_event(NULL)
 	, _lock(engine.store()->lock(), Glib::NOT_LOCK)
 {
@@ -81,7 +81,7 @@ Delete::pre_process()
 		return Event::pre_process_done(NOT_DELETABLE, _path);
 	}
 
-	PatchImpl* parent = _block ? _block->parent_patch() : _port->parent_patch();
+	GraphImpl* parent = _block ? _block->parent_graph() : _port->parent_graph();
 	if (!parent) {
 		return Event::pre_process_done(INTERNAL_ERROR, _path);
 	}
@@ -94,7 +94,7 @@ Delete::pre_process()
 		_disconnect_event->pre_process();
 		
 		if (parent->enabled()) {
-			_compiled_patch = parent->compile();
+			_compiled_graph = parent->compile();
 		}
 	} else if (_port) {
 		parent->remove_port(*_port);
@@ -102,7 +102,7 @@ Delete::pre_process()
 		_disconnect_event->pre_process();
 
 		if (parent->enabled()) {
-			_compiled_patch = parent->compile();
+			_compiled_graph = parent->compile();
 			_ports_array    = parent->build_ports_array();
 			assert(_ports_array->size() == parent->num_ports_non_rt());
 		}
@@ -122,7 +122,7 @@ Delete::execute(ProcessContext& context)
 		_disconnect_event->execute(context);
 	}
 
-	PatchImpl* parent = _block ? _block->parent_patch() : _port->parent_patch();
+	GraphImpl* parent = _block ? _block->parent_graph() : _port->parent_graph();
 	if (_port) {
 		_engine.maid()->dispose(parent->external_ports());
 		parent->external_ports(_ports_array);
@@ -133,8 +133,8 @@ Delete::execute(ProcessContext& context)
 	}
 
 	if (parent) {
-		_engine.maid()->dispose(parent->compiled_patch());
-		parent->compiled_patch(_compiled_patch);
+		_engine.maid()->dispose(parent->compiled_graph());
+		parent->compiled_graph(_compiled_graph);
 	}
 }
 
diff --git a/src/server/events/Delete.hpp b/src/server/events/Delete.hpp
index c14c5567..74046f82 100644
--- a/src/server/events/Delete.hpp
+++ b/src/server/events/Delete.hpp
@@ -20,7 +20,7 @@
 #include "ingen/Store.hpp"
 
 #include "Event.hpp"
-#include "PatchImpl.hpp"
+#include "GraphImpl.hpp"
 #include "ControlBindings.hpp"
 
 namespace Raul {
@@ -31,7 +31,7 @@ namespace Ingen {
 namespace Server {
 
 class BlockImpl;
-class CompiledPatch;
+class CompiledGraph;
 class DuplexPort;
 class EnginePort;
 class PortImpl;
@@ -75,8 +75,8 @@ private:
 	SharedPtr<BlockImpl>     _block;               ///< Non-NULL iff a block
 	SharedPtr<DuplexPort>    _port;                ///< Non-NULL iff a port
 	EnginePort*              _engine_port;
-	Raul::Array<PortImpl*>*  _ports_array;         ///< New (external) ports for Patch
-	CompiledPatch*           _compiled_patch;      ///< Patch's new process order
+	Raul::Array<PortImpl*>*  _ports_array;         ///< New (external) ports for Graph
+	CompiledGraph*           _compiled_graph;      ///< Graph's new process order
 	DisconnectAll*           _disconnect_event;
 
 	SharedPtr<ControlBindings::Bindings> _removed_bindings;
diff --git a/src/server/events/Delta.cpp b/src/server/events/Delta.cpp
index 3b31cedb..06bd150c 100644
--- a/src/server/events/Delta.cpp
+++ b/src/server/events/Delta.cpp
@@ -25,11 +25,11 @@
 #include "Broadcaster.hpp"
 #include "ControlBindings.hpp"
 #include "CreateBlock.hpp"
-#include "CreatePatch.hpp"
+#include "CreateGraph.hpp"
 #include "CreatePort.hpp"
 #include "Delta.hpp"
 #include "Engine.hpp"
-#include "PatchImpl.hpp"
+#include "GraphImpl.hpp"
 #include "PluginImpl.hpp"
 #include "PortImpl.hpp"
 #include "PortType.hpp"
@@ -59,8 +59,8 @@ Delta::Delta(Engine&              engine,
 	, _properties(properties)
 	, _remove(remove)
 	, _object(NULL)
-	, _patch(NULL)
-	, _compiled_patch(NULL)
+	, _graph(NULL)
+	, _compiled_graph(NULL)
 	, _context(context)
 	, _create(create)
 {
@@ -122,11 +122,11 @@ Delta::pre_process()
 
 	if (is_graph_object && !_object) {
 		Raul::Path path(GraphObject::uri_to_path(_subject));
-		bool is_patch = false, is_block = false, is_port = false, is_output = false;
-		Ingen::Resource::type(uris, _properties, is_patch, is_block, is_port, is_output);
+		bool is_graph = false, is_block = false, is_port = false, is_output = false;
+		Ingen::Resource::type(uris, _properties, is_graph, is_block, is_port, is_output);
 
-		if (is_patch) {
-			_create_event = new CreatePatch(
+		if (is_graph) {
+			_create_event = new CreateGraph(
 				_engine, _request_client, _request_id, _time, path, _properties);
 		} else if (is_block) {
 			_create_event = new CreateBlock(
@@ -194,13 +194,13 @@ Delta::pre_process()
 						_status = BAD_OBJECT_TYPE;
 					}
 				}
-			} else if ((_patch = dynamic_cast<PatchImpl*>(_object))) {
+			} else if ((_graph = dynamic_cast<GraphImpl*>(_object))) {
 				if (key == uris.ingen_enabled) {
 					if (value.type() == uris.forge.Bool) {
 						op = ENABLE;
 						// FIXME: defer this until all other metadata has been processed
-						if (value.get_bool() && !_patch->enabled())
-							_compiled_patch = _patch->compile();
+						if (value.get_bool() && !_graph->enabled())
+							_compiled_graph = _graph->compile();
 					} else {
 						_status = BAD_VALUE_TYPE;
 					}
@@ -210,7 +210,7 @@ Delta::pre_process()
 							_status = INVALID_POLY;
 						} else {
 							op = POLYPHONY;
-							_patch->prepare_internal_poly(
+							_graph->prepare_internal_poly(
 								*_engine.buffer_factory(), value.get_int32());
 						}
 					} else {
@@ -218,7 +218,7 @@ Delta::pre_process()
 					}
 				}
 			} else if (key == uris.ingen_polyphonic) {
-				PatchImpl* parent = dynamic_cast<PatchImpl*>(obj->parent());
+				GraphImpl* parent = dynamic_cast<GraphImpl*>(obj->parent());
 				if (parent) {
 					if (value.type() == uris.forge.Bool) {
 						op = POLYPHONIC;
@@ -286,17 +286,17 @@ Delta::execute(ProcessContext& context)
 			break;
 		case ENABLE:
 			if (value.get_bool()) {
-				if (_compiled_patch) {
-					_engine.maid()->dispose(_patch->compiled_patch());
-					_patch->compiled_patch(_compiled_patch);
+				if (_compiled_graph) {
+					_engine.maid()->dispose(_graph->compiled_graph());
+					_graph->compiled_graph(_compiled_graph);
 				}
-				_patch->enable();
+				_graph->enable();
 			} else {
-				_patch->disable(context);
+				_graph->disable(context);
 			}
 			break;
 		case POLYPHONIC: {
-			PatchImpl* parent = reinterpret_cast<PatchImpl*>(object->parent());
+			GraphImpl* parent = reinterpret_cast<GraphImpl*>(object->parent());
 			if (value.get_bool()) {
 				object->apply_poly(
 					context, *_engine.maid(), parent->internal_poly_process());
@@ -305,7 +305,7 @@ Delta::execute(ProcessContext& context)
 			}
 		} break;
 		case POLYPHONY:
-			if (!_patch->apply_internal_poly(context,
+			if (!_graph->apply_internal_poly(context,
 			                                 *_engine.buffer_factory(),
 			                                 *_engine.maid(),
 			                                 value.get_int32())) {
diff --git a/src/server/events/Delta.hpp b/src/server/events/Delta.hpp
index 6bb6508a..c3a28fbb 100644
--- a/src/server/events/Delta.hpp
+++ b/src/server/events/Delta.hpp
@@ -30,9 +30,9 @@ class Resource;
 
 namespace Server {
 
-class CompiledPatch;
+class CompiledGraph;
 class Engine;
-class PatchImpl;
+class GraphImpl;
 class ProcessContext;
 
 namespace Events {
@@ -105,8 +105,8 @@ private:
 	Resource::Properties     _properties;
 	Resource::Properties     _remove;
 	Ingen::Resource*         _object;
-	PatchImpl*               _patch;
-	CompiledPatch*           _compiled_patch;
+	GraphImpl*               _graph;
+	CompiledGraph*           _compiled_graph;
 	Resource::Graph          _context;
 	ControlBindings::Key     _binding;
 	bool                     _create;
diff --git a/src/server/events/Disconnect.cpp b/src/server/events/Disconnect.cpp
index 9cf2974a..914e3375 100644
--- a/src/server/events/Disconnect.cpp
+++ b/src/server/events/Disconnect.cpp
@@ -27,9 +27,9 @@
 #include "DuplexPort.hpp"
 #include "EdgeImpl.hpp"
 #include "Engine.hpp"
+#include "GraphImpl.hpp"
 #include "InputPort.hpp"
 #include "OutputPort.hpp"
-#include "PatchImpl.hpp"
 #include "PortImpl.hpp"
 #include "ProcessContext.hpp"
 #include "ThreadManager.hpp"
@@ -48,21 +48,21 @@ Disconnect::Disconnect(Engine&              engine,
 	: Event(engine, client, id, timestamp)
 	, _tail_path(tail_path)
 	, _head_path(head_path)
-	, _patch(NULL)
+	, _graph(NULL)
 	, _impl(NULL)
-	, _compiled_patch(NULL)
+	, _compiled_graph(NULL)
 {
 }
 
 Disconnect::Impl::Impl(Engine&     e,
-                       PatchImpl*  patch,
+                       GraphImpl*  graph,
                        OutputPort* s,
                        InputPort*  d)
 	: _engine(e)
 	, _src_output_port(s)
 	, _dst_input_port(d)
-	, _patch(patch)
-	, _edge(patch->remove_edge(_src_output_port, _dst_input_port))
+	, _graph(graph)
+	, _edge(graph->remove_edge(_src_output_port, _dst_input_port))
 	, _buffers(NULL)
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
@@ -133,25 +133,25 @@ Disconnect::pre_process()
 	BlockImpl* const src_block = tail->parent_block();
 	BlockImpl* const dst_block = head->parent_block();
 
-	if (src_block->parent_patch() != dst_block->parent_patch()) {
-		// Edge to a patch port from inside the patch
+	if (src_block->parent_graph() != dst_block->parent_graph()) {
+		// Edge to a graph port from inside the graph
 		assert(src_block->parent() == dst_block || dst_block->parent() == src_block);
 		if (src_block->parent() == dst_block) {
-			_patch = dynamic_cast<PatchImpl*>(dst_block);
+			_graph = dynamic_cast<GraphImpl*>(dst_block);
 		} else {
-			_patch = dynamic_cast<PatchImpl*>(src_block);
+			_graph = dynamic_cast<GraphImpl*>(src_block);
 		}
-	} else if (src_block == dst_block && dynamic_cast<PatchImpl*>(src_block)) {
-		// Edge from a patch input to a patch output (pass through)
-		_patch = dynamic_cast<PatchImpl*>(src_block);
+	} else if (src_block == dst_block && dynamic_cast<GraphImpl*>(src_block)) {
+		// Edge from a graph input to a graph output (pass through)
+		_graph = dynamic_cast<GraphImpl*>(src_block);
 	} else {
 		// Normal edge between blocks with the same parent
-		_patch = src_block->parent_patch();
+		_graph = src_block->parent_graph();
 	}
 
-	assert(_patch);
+	assert(_graph);
 
-	if (!_patch->has_edge(tail, head)) {
+	if (!_graph->has_edge(tail, head)) {
 		return Event::pre_process_done(NOT_FOUND, _head_path);
 	}
 
@@ -160,12 +160,12 @@ Disconnect::pre_process()
 	}
 
 	_impl = new Impl(_engine,
-	                 _patch,
+	                 _graph,
 	                 dynamic_cast<OutputPort*>(tail),
 	                 dynamic_cast<InputPort*>(head));
 
-	if (_patch->enabled())
-		_compiled_patch = _patch->compile();
+	if (_graph->enabled())
+		_compiled_graph = _graph->compile();
 
 	return Event::pre_process_done(SUCCESS);
 }
@@ -207,8 +207,8 @@ Disconnect::execute(ProcessContext& context)
 			return;
 		}
 
-		_engine.maid()->dispose(_patch->compiled_patch());
-		_patch->compiled_patch(_compiled_patch);
+		_engine.maid()->dispose(_graph->compiled_graph());
+		_graph->compiled_graph(_compiled_graph);
 	}
 }
 
diff --git a/src/server/events/Disconnect.hpp b/src/server/events/Disconnect.hpp
index b008025a..feb1d17f 100644
--- a/src/server/events/Disconnect.hpp
+++ b/src/server/events/Disconnect.hpp
@@ -18,10 +18,11 @@
 #define INGEN_EVENTS_DISCONNECT_HPP
 
 #include "raul/Path.hpp"
+
+#include "BufferFactory.hpp"
 #include "Event.hpp"
+#include "GraphImpl.hpp"
 #include "types.hpp"
-#include "PatchImpl.hpp"
-#include "BufferFactory.hpp"
 
 namespace Raul {
 template <typename T> class Array;
@@ -30,7 +31,7 @@ template <typename T> class Array;
 namespace Ingen {
 namespace Server {
 
-class CompiledPatch;
+class CompiledGraph;
 class InputPort;
 class OutputPort;
 class PortImpl;
@@ -58,7 +59,7 @@ public:
 	class Impl {
 	public:
 		Impl(Engine&     e,
-		     PatchImpl*  patch,
+		     GraphImpl*  graph,
 		     OutputPort* s,
 		     InputPort*  d);
 
@@ -70,7 +71,7 @@ public:
 		Engine&                 _engine;
 		OutputPort*             _src_output_port;
 		InputPort*              _dst_input_port;
-		PatchImpl*              _patch;
+		GraphImpl*              _graph;
 		SharedPtr<EdgeImpl>     _edge;
 		Raul::Array<BufferRef>* _buffers;
 	};
@@ -78,9 +79,9 @@ public:
 private:
 	const Raul::Path _tail_path;
 	const Raul::Path _head_path;
-	PatchImpl*       _patch;
+	GraphImpl*       _graph;
 	Impl*            _impl;
-	CompiledPatch*   _compiled_patch;
+	CompiledGraph*   _compiled_graph;
 };
 
 } // namespace Events
diff --git a/src/server/events/DisconnectAll.cpp b/src/server/events/DisconnectAll.cpp
index 4169622d..dbff2ab3 100644
--- a/src/server/events/DisconnectAll.cpp
+++ b/src/server/events/DisconnectAll.cpp
@@ -28,9 +28,9 @@
 #include "Broadcaster.hpp"
 #include "EdgeImpl.hpp"
 #include "Engine.hpp"
+#include "GraphImpl.hpp"
 #include "InputPort.hpp"
 #include "OutputPort.hpp"
-#include "PatchImpl.hpp"
 #include "PortImpl.hpp"
 #include "events/Disconnect.hpp"
 #include "events/DisconnectAll.hpp"
@@ -52,7 +52,7 @@ DisconnectAll::DisconnectAll(Engine&              engine,
 	, _parent(NULL)
 	, _block(NULL)
 	, _port(NULL)
-	, _compiled_patch(NULL)
+	, _compiled_graph(NULL)
 	, _deleting(false)
 {
 }
@@ -60,7 +60,7 @@ DisconnectAll::DisconnectAll(Engine&              engine,
 /** Internal version for use by other events.
  */
 DisconnectAll::DisconnectAll(Engine&      engine,
-                             PatchImpl*   parent,
+                             GraphImpl*   parent,
                              GraphObject* object)
 	: Event(engine)
 	, _parent_path(parent->path())
@@ -68,7 +68,7 @@ DisconnectAll::DisconnectAll(Engine&      engine,
 	, _parent(parent)
 	, _block(dynamic_cast<BlockImpl*>(object))
 	, _port(dynamic_cast<PortImpl*>(object))
-	, _compiled_patch(NULL)
+	, _compiled_graph(NULL)
 	, _deleting(true)
 {
 }
@@ -87,7 +87,7 @@ DisconnectAll::pre_process()
 	if (!_deleting) {
 		lock.acquire();
 
-		_parent = dynamic_cast<PatchImpl*>(_engine.store()->get(_parent_path));
+		_parent = dynamic_cast<GraphImpl*>(_engine.store()->get(_parent_path));
 		if (!_parent) {
 			return Event::pre_process_done(PARENT_NOT_FOUND, _parent_path);
 		}
@@ -98,8 +98,8 @@ DisconnectAll::pre_process()
 			return Event::pre_process_done(NOT_FOUND, _path);
 		}
 
-		if (object->parent_patch() != _parent
-		    && object->parent()->parent_patch() != _parent) {
+		if (object->parent_graph() != _parent
+		    && object->parent()->parent_graph() != _parent) {
 			return Event::pre_process_done(INVALID_PARENT_PATH, _parent_path);
 		}
 
@@ -138,7 +138,7 @@ DisconnectAll::pre_process()
 	}
 
 	if (!_deleting && _parent->enabled())
-		_compiled_patch = _parent->compile();
+		_compiled_graph = _parent->compile();
 
 	return Event::pre_process_done(SUCCESS);
 }
@@ -153,8 +153,8 @@ DisconnectAll::execute(ProcessContext& context)
 		}
 	}
 
-	_engine.maid()->dispose(_parent->compiled_patch());
-	_parent->compiled_patch(_compiled_patch);
+	_engine.maid()->dispose(_parent->compiled_graph());
+	_parent->compiled_graph(_compiled_graph);
 }
 
 void
diff --git a/src/server/events/DisconnectAll.hpp b/src/server/events/DisconnectAll.hpp
index 68ba8ebe..8a785722 100644
--- a/src/server/events/DisconnectAll.hpp
+++ b/src/server/events/DisconnectAll.hpp
@@ -28,8 +28,8 @@ namespace Ingen {
 namespace Server {
 
 class BlockImpl;
-class CompiledPatch;
-class PatchImpl;
+class CompiledGraph;
+class GraphImpl;
 class PortImpl;
 
 namespace Events {
@@ -51,7 +51,7 @@ public:
 	              const Raul::Path&    object);
 
 	DisconnectAll(Engine&      engine,
-	              PatchImpl*   parent,
+	              GraphImpl*   parent,
 	              GraphObject* object);
 
 	~DisconnectAll();
@@ -65,11 +65,11 @@ private:
 
 	Raul::Path     _parent_path;
 	Raul::Path     _path;
-	PatchImpl*     _parent;
+	GraphImpl*     _parent;
 	BlockImpl*     _block;
 	PortImpl*      _port;
 	Impls          _impls;
-	CompiledPatch* _compiled_patch;
+	CompiledGraph* _compiled_graph;
 	bool           _deleting;
 };
 
diff --git a/src/server/events/Get.cpp b/src/server/events/Get.cpp
index 24b4daae..c452328e 100644
--- a/src/server/events/Get.cpp
+++ b/src/server/events/Get.cpp
@@ -26,7 +26,7 @@
 #include "Driver.hpp"
 #include "Engine.hpp"
 #include "Get.hpp"
-#include "PatchImpl.hpp"
+#include "GraphImpl.hpp"
 #include "PluginImpl.hpp"
 #include "PortImpl.hpp"
 
@@ -35,7 +35,7 @@ namespace Server {
 namespace Events {
 
 static void
-send_patch(Interface* client, const PatchImpl* patch);
+send_graph(Interface* client, const GraphImpl* graph);
 
 Get::Get(Engine&              engine,
          SharedPtr<Interface> client,
@@ -87,8 +87,8 @@ static void
 send_block(Interface* client, const BlockImpl* block)
 {
 	PluginImpl* const plugin = block->plugin_impl();
-	if (plugin->type() == Plugin::Patch) {
-		send_patch(client, (const PatchImpl*)block);
+	if (plugin->type() == Plugin::Graph) {
+		send_graph(client, (const GraphImpl*)block);
 	} else {
 		client->put(block->uri(), block->properties());
 		for (size_t j = 0; j < block->num_ports(); ++j) {
@@ -98,30 +98,30 @@ send_block(Interface* client, const BlockImpl* block)
 }
 
 static void
-send_patch(Interface* client, const PatchImpl* patch)
+send_graph(Interface* client, const GraphImpl* graph)
 {
-	client->put(patch->uri(),
-	            patch->properties(Resource::INTERNAL),
+	client->put(graph->uri(),
+	            graph->properties(Resource::INTERNAL),
 	            Resource::INTERNAL);
 
-	client->put(patch->uri(),
-	            patch->properties(Resource::EXTERNAL),
+	client->put(graph->uri(),
+	            graph->properties(Resource::EXTERNAL),
 	            Resource::EXTERNAL);
 
 	// Send blocks
-	for (PatchImpl::Blocks::const_iterator j = patch->blocks().begin();
-	     j != patch->blocks().end(); ++j) {
+	for (GraphImpl::Blocks::const_iterator j = graph->blocks().begin();
+	     j != graph->blocks().end(); ++j) {
 		send_block(client, &*j);
 	}
 
 	// Send ports
-	for (uint32_t i = 0; i < patch->num_ports_non_rt(); ++i) {
-		send_port(client, patch->port_impl(i));
+	for (uint32_t i = 0; i < graph->num_ports_non_rt(); ++i) {
+		send_port(client, graph->port_impl(i));
 	}
 
 	// Send edges
-	for (PatchImpl::Edges::const_iterator j = patch->edges().begin();
-	     j != patch->edges().end(); ++j) {
+	for (GraphImpl::Edges::const_iterator j = graph->edges().begin();
+	     j != graph->edges().end(); ++j) {
 		client->connect(j->second->tail_path(), j->second->head_path());
 	}
 }
@@ -142,10 +142,10 @@ Get::post_process()
 		} else if (_object) {
 			_request_client->bundle_begin();
 			const BlockImpl* block = NULL;
-			const PatchImpl* patch = NULL;
+			const GraphImpl* graph = NULL;
 			const PortImpl*  port  = NULL;
-			if ((patch = dynamic_cast<const PatchImpl*>(_object))) {
-				send_patch(_request_client.get(), patch);
+			if ((graph = dynamic_cast<const GraphImpl*>(_object))) {
+				send_graph(_request_client.get(), graph);
 			} else if ((block = dynamic_cast<const BlockImpl*>(_object))) {
 				send_block(_request_client.get(), block);
 			} else if ((port = dynamic_cast<const PortImpl*>(_object))) {
diff --git a/src/server/events/Move.cpp b/src/server/events/Move.cpp
index d5b4d116..58f47e13 100644
--- a/src/server/events/Move.cpp
+++ b/src/server/events/Move.cpp
@@ -24,7 +24,7 @@
 #include "Driver.hpp"
 #include "Engine.hpp"
 #include "EnginePort.hpp"
-#include "PatchImpl.hpp"
+#include "GraphImpl.hpp"
 #include "events/Move.hpp"
 
 namespace Ingen {
diff --git a/src/server/events/Move.hpp b/src/server/events/Move.hpp
index 6c38347f..6e30cba6 100644
--- a/src/server/events/Move.hpp
+++ b/src/server/events/Move.hpp
@@ -25,7 +25,7 @@
 namespace Ingen {
 namespace Server {
 
-class PatchImpl;
+class GraphImpl;
 class PortImpl;
 
 namespace Events {
@@ -62,7 +62,7 @@ public:
 private:
 	const Raul::Path _old_path;
 	const Raul::Path _new_path;
-	PatchImpl*       _parent_patch;
+	GraphImpl*       _parent_graph;
 };
 
 } // namespace Events
diff --git a/src/server/ingen_lv2.cpp b/src/server/ingen_lv2.cpp
index 5158e441..26f239da 100644
--- a/src/server/ingen_lv2.cpp
+++ b/src/server/ingen_lv2.cpp
@@ -49,7 +49,7 @@
 #include "Engine.hpp"
 #include "EnginePort.hpp"
 #include "EventWriter.hpp"
-#include "PatchImpl.hpp"
+#include "GraphImpl.hpp"
 #include "PostProcessor.hpp"
 #include "ProcessContext.hpp"
 #include "ThreadManager.hpp"
@@ -58,9 +58,9 @@
 #define NS_RDF   "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 #define NS_RDFS  "http://www.w3.org/2000/01/rdf-schema#"
 
-/** Record of a patch in this bundle. */
-struct LV2Patch {
-	LV2Patch(const std::string& u, const std::string& f);
+/** Record of a graph in this bundle. */
+struct LV2Graph {
+	LV2Graph(const std::string& u, const std::string& f);
 
 	const std::string uri;
 	const std::string filename;
@@ -72,9 +72,9 @@ class Lib {
 public:
 	explicit Lib(const char* bundle_path);
 
-	typedef std::vector< SharedPtr<const LV2Patch> > Patches;
+	typedef std::vector< SharedPtr<const LV2Graph> > Graphes;
 
-	Patches patches;
+	Graphes graphes;
 };
 
 namespace Ingen {
@@ -101,7 +101,7 @@ public:
 		          *this)
 		, _from_ui(block_length * sizeof(float))  // FIXME: size
 		, _to_ui(block_length * sizeof(float))  // FIXME: size
-		, _root_patch(NULL)
+		, _root_graph(NULL)
 		, _notify_capacity(0)
 		, _block_length(block_length)
 		, _sample_rate(sample_rate)
@@ -111,28 +111,28 @@ public:
 	{}
 
 	void pre_process_port(ProcessContext& context, EnginePort* port) {
-		PortImpl* patch_port = port->patch_port();
+		PortImpl* graph_port = port->graph_port();
 		void*     buffer     = port->buffer();
 
-		if (!patch_port->is_input() || !buffer) {
+		if (!graph_port->is_input() || !buffer) {
 			return;
 		}
 
-		Buffer* const patch_buf = patch_port->buffer(0).get();
-		if (patch_port->is_a(PortType::AUDIO) ||
-		    patch_port->is_a(PortType::CV)) {
-			memcpy(patch_buf->samples(),
+		Buffer* const graph_buf = graph_port->buffer(0).get();
+		if (graph_port->is_a(PortType::AUDIO) ||
+		    graph_port->is_a(PortType::CV)) {
+			memcpy(graph_buf->samples(),
 			       buffer,
 			       context.nframes() * sizeof(float));
-		} else if (patch_port->is_a(PortType::CONTROL)) {
-			patch_buf->samples()[0] = ((float*)buffer)[0];
+		} else if (graph_port->is_a(PortType::CONTROL)) {
+			graph_buf->samples()[0] = ((float*)buffer)[0];
 		} else {
 			LV2_Atom_Sequence* seq      = (LV2_Atom_Sequence*)buffer;
 			bool               enqueued = false;
-			URIs&              uris     = patch_port->bufs().uris();
-			patch_buf->prepare_write(context);
+			URIs&              uris     = graph_port->bufs().uris();
+			graph_buf->prepare_write(context);
 			LV2_ATOM_SEQUENCE_FOREACH(seq, ev) {
-				if (!patch_buf->append_event(
+				if (!graph_buf->append_event(
 					    ev->time.frames, ev->body.size, ev->body.type,
 					    (const uint8_t*)LV2_ATOM_BODY(&ev->body))) {
 					_engine.log().warn("Failed to write to buffer, event lost!\n");
@@ -151,27 +151,27 @@ public:
 	}
 
 	void post_process_port(ProcessContext& context, EnginePort* port) {
-		PortImpl* patch_port = port->patch_port();
+		PortImpl* graph_port = port->graph_port();
 		void*     buffer     = port->buffer();
 
-		if (patch_port->is_input() || !buffer) {
+		if (graph_port->is_input() || !buffer) {
 			return;
 		}
 
-		Buffer* patch_buf = patch_port->buffer(0).get();
-		if (patch_port->is_a(PortType::AUDIO) ||
-		    patch_port->is_a(PortType::CV)) {
+		Buffer* graph_buf = graph_port->buffer(0).get();
+		if (graph_port->is_a(PortType::AUDIO) ||
+		    graph_port->is_a(PortType::CV)) {
 			memcpy(buffer,
-			       patch_buf->samples(),
+			       graph_buf->samples(),
 			       context.nframes() * sizeof(float));
-		} else if (patch_port->is_a(PortType::CONTROL)) {
-			((float*)buffer)[0] = patch_buf->samples()[0];
-		} else if (patch_port->index() != 1) {
+		} else if (graph_port->is_a(PortType::CONTROL)) {
+			((float*)buffer)[0] = graph_buf->samples()[0];
+		} else if (graph_port->index() != 1) {
 			/* Copy Sequence output to LV2 buffer, except notify output which
 			   is written by flush_to_ui() (TODO: merge) */
 			memcpy(buffer,
-			       patch_buf->atom(),
-			       sizeof(LV2_Atom) + patch_buf->atom()->size);
+			       graph_buf->atom(),
+			       sizeof(LV2_Atom) + graph_buf->atom()->size);
 		}
 	}
 
@@ -204,12 +204,12 @@ public:
 		_main_sem.post();
 	}
 
-	virtual void       set_root_patch(PatchImpl* patch) { _root_patch = patch; }
-	virtual PatchImpl* root_patch()                     { return _root_patch; }
+	virtual void       set_root_graph(GraphImpl* graph) { _root_graph = graph; }
+	virtual GraphImpl* root_graph()                     { return _root_graph; }
 
 	virtual EnginePort* get_port(const Raul::Path& path) {
 		for (Ports::iterator i = _ports.begin(); i != _ports.end(); ++i) {
-			if ((*i)->patch_port()->path() == path) {
+			if ((*i)->graph_port()->path() == path) {
 				return *i;
 			}
 		}
@@ -221,7 +221,7 @@ public:
 	 * It is only called on initial load.
 	 */
 	virtual void add_port(ProcessContext& context, EnginePort* port) {
-		const uint32_t index = port->patch_port()->index();
+		const uint32_t index = port->graph_port()->index();
 		if (_ports.size() <= index) {
 			_ports.resize(index + 1);
 		}
@@ -241,8 +241,8 @@ public:
 	virtual void rename_port(const Raul::Path& old_path,
 	                         const Raul::Path& new_path) {}
 
-	virtual EnginePort* create_port(DuplexPort* patch_port) {
-		return new EnginePort(patch_port);
+	virtual EnginePort* create_port(DuplexPort* graph_port) {
+		return new EnginePort(graph_port);
 	}
 
 	/** Called in run thread for events received at control input port. */
@@ -359,7 +359,7 @@ private:
 	AtomWriter       _writer;
 	Raul::RingBuffer _from_ui;
 	Raul::RingBuffer _to_ui;
-	PatchImpl*       _root_patch;
+	GraphImpl*       _root_graph;
 	uint32_t         _notify_capacity;
 	SampleCount      _block_length;
 	SampleCount      _sample_rate;
@@ -422,13 +422,13 @@ struct IngenPlugin {
 	char**        argv;
 };
 
-static Lib::Patches
-find_patches(const Glib::ustring& manifest_uri)
+static Lib::Graphes
+find_graphes(const Glib::ustring& manifest_uri)
 {
 	Sord::World      world;
 	const Sord::URI  base(world, manifest_uri);
 	const Sord::Node nil;
-	const Sord::URI  ingen_Patch (world, NS_INGEN "Patch");
+	const Sord::URI  ingen_Graph (world, NS_INGEN "Graph");
 	const Sord::URI  rdf_type    (world, NS_RDF   "type");
 	const Sord::URI  rdfs_seeAlso(world, NS_RDFS  "seeAlso");
 
@@ -436,22 +436,22 @@ find_patches(const Glib::ustring& manifest_uri)
 	Sord::Model model(world, manifest_uri);
 	model.load_file(env, SERD_TURTLE, manifest_uri);
 
-	Lib::Patches patches;
-	for (Sord::Iter i = model.find(nil, rdf_type, ingen_Patch); !i.end(); ++i) {
-		const Sord::Node  patch     = i.get_subject();
-		Sord::Iter        f         = model.find(patch, rdfs_seeAlso, nil);
-		const std::string patch_uri = patch.to_c_string();
+	Lib::Graphes graphes;
+	for (Sord::Iter i = model.find(nil, rdf_type, ingen_Graph); !i.end(); ++i) {
+		const Sord::Node  graph     = i.get_subject();
+		Sord::Iter        f         = model.find(graph, rdfs_seeAlso, nil);
+		const std::string graph_uri = graph.to_c_string();
 		if (!f.end()) {
 			const uint8_t* file_uri  = f.get_object().to_u_string();
 			uint8_t*       file_path = serd_file_uri_parse(file_uri, NULL);
-			patches.push_back(boost::shared_ptr<const LV2Patch>(
-				                  new LV2Patch(patch_uri, (const char*)file_path)));
+			graphes.push_back(boost::shared_ptr<const LV2Graph>(
+				                  new LV2Graph(graph_uri, (const char*)file_path)));
 			free(file_path);
 		}
 	}
 
 	serd_env_free(env);
-	return patches;
+	return graphes;
 }
 
 static LV2_Handle
@@ -482,19 +482,19 @@ ingen_instantiate(const LV2_Descriptor*    descriptor,
 	}
 
 	set_bundle_path(bundle_path);
-	Lib::Patches patches = find_patches(
+	Lib::Graphes graphes = find_graphes(
 		Glib::filename_to_uri(Ingen::bundle_file_path("manifest.ttl")));
 
-	const LV2Patch* patch = NULL;
-	for (Lib::Patches::iterator i = patches.begin(); i != patches.end(); ++i) {
+	const LV2Graph* graph = NULL;
+	for (Lib::Graphes::iterator i = graphes.begin(); i != graphes.end(); ++i) {
 		if ((*i)->uri == descriptor->URI) {
-			patch = (*i).get();
+			graph = (*i).get();
 			break;
 		}
 	}
 
-	if (!patch) {
-		const std::string msg((Raul::fmt("Could not find patch %1%\n")
+	if (!graph) {
+		const std::string msg((Raul::fmt("Could not find graph %1%\n")
 		                       % descriptor->URI).str());
 		if (log) {
 			log->vprintf(log->handle,
@@ -560,14 +560,14 @@ ingen_instantiate(const LV2_Descriptor*    descriptor,
 
 	plugin->world->parser()->parse_file(plugin->world,
 	                                    plugin->world->interface().get(),
-	                                    patch->filename);
+	                                    graph->filename);
 
 	while (engine->pending_events()) {
 		engine->process_events();
 		engine->post_processor()->process();
 	}
 
-	/* Register client after loading patch so the to-ui ring does not overflow.
+	/* Register client after loading graph so the to-ui ring does not overflow.
 	   Since we are not yet rolling, it won't be drained, causing a deadlock. */
 	SharedPtr<Interface> client(&driver->writer(), NullDeleter<Interface>);
 	interface->set_respondee(client);
@@ -586,7 +586,7 @@ ingen_connect_port(LV2_Handle instance, uint32_t port, void* data)
 	LV2Driver*      driver = (LV2Driver*)engine->driver();
 	if (port < driver->ports().size()) {
 		driver->ports().at(port)->set_buffer(data);
-		assert(driver->ports().at(port)->patch_port()->index() == port);
+		assert(driver->ports().at(port)->graph_port()->index() == port);
 		assert(driver->ports().at(port)->buffer() == data);
 	} else {
 		engine->log().error(Raul::fmt("Connect to non-existent port %1%\n")
@@ -668,7 +668,7 @@ ingen_save(LV2_Handle                instance,
 	LV2_URID atom_Path = plugin->map->map(plugin->map->handle,
 	                                      LV2_ATOM__Path);
 
-	char* real_path  = make_path->path(make_path->handle, "patch.ttl");
+	char* real_path  = make_path->path(make_path->handle, "graph.ttl");
 	char* state_path = map_path->abstract_path(map_path->handle, real_path);
 
 	Ingen::Store::iterator root = plugin->world->store()->find(Raul::Path("/"));
@@ -736,7 +736,7 @@ ingen_extension_data(const char* uri)
 	return NULL;
 }
 
-LV2Patch::LV2Patch(const std::string& u, const std::string& f)
+LV2Graph::LV2Graph(const std::string& u, const std::string& f)
 	: uri(u)
 	, filename(f)
 {
@@ -753,7 +753,7 @@ LV2Patch::LV2Patch(const std::string& u, const std::string& f)
 Lib::Lib(const char* bundle_path)
 {
 	Ingen::set_bundle_path(bundle_path);
-	patches = find_patches(
+	graphes = find_graphes(
 		Glib::filename_to_uri(Ingen::bundle_file_path("manifest.ttl")));
 }
 
@@ -768,7 +768,7 @@ static const LV2_Descriptor*
 lib_get_plugin(LV2_Lib_Handle handle, uint32_t index)
 {
 	Lib* lib = (Lib*)handle;
-	return index < lib->patches.size() ? &lib->patches[index]->descriptor : NULL;
+	return index < lib->graphes.size() ? &lib->graphes[index]->descriptor : NULL;
 }
 
 /** LV2 plugin library entry point */
diff --git a/src/server/internals/Controller.cpp b/src/server/internals/Controller.cpp
index 0e8d125e..f38545d3 100644
--- a/src/server/internals/Controller.cpp
+++ b/src/server/internals/Controller.cpp
@@ -45,7 +45,7 @@ ControllerNode::ControllerNode(InternalPlugin*     plugin,
                                BufferFactory&      bufs,
                                const Raul::Symbol& symbol,
                                bool                polyphonic,
-                               PatchImpl*          parent,
+                               GraphImpl*          parent,
                                SampleRate          srate)
 	: BlockImpl(plugin, symbol, false, parent, srate)
 	, _learning(false)
diff --git a/src/server/internals/Controller.hpp b/src/server/internals/Controller.hpp
index 23401826..6cb78397 100644
--- a/src/server/internals/Controller.hpp
+++ b/src/server/internals/Controller.hpp
@@ -42,7 +42,7 @@ public:
 	               BufferFactory&      bufs,
 	               const Raul::Symbol& symbol,
 	               bool                polyphonic,
-	               PatchImpl*          parent,
+	               GraphImpl*          parent,
 	               SampleRate          srate);
 
 	void process(ProcessContext& context);
diff --git a/src/server/internals/Delay.cpp b/src/server/internals/Delay.cpp
index 1e7ed5a5..c528a068 100644
--- a/src/server/internals/Delay.cpp
+++ b/src/server/internals/Delay.cpp
@@ -25,10 +25,10 @@
 #include "Buffer.hpp"
 #include "Driver.hpp"
 #include "Engine.hpp"
+#include "GraphImpl.hpp"
 #include "InputPort.hpp"
 #include "InternalPlugin.hpp"
 #include "OutputPort.hpp"
-#include "PatchImpl.hpp"
 #include "ProcessContext.hpp"
 #include "internals/Delay.hpp"
 #include "util.hpp"
@@ -53,7 +53,7 @@ DelayNode::DelayNode(InternalPlugin*     plugin,
                      BufferFactory&      bufs,
                      const Raul::Symbol& symbol,
                      bool                polyphonic,
-                     PatchImpl*          parent,
+                     GraphImpl*          parent,
                      SampleRate          srate)
 	: BlockImpl(plugin, symbol, polyphonic, parent, srate)
 	, _buffer(0)
diff --git a/src/server/internals/Delay.hpp b/src/server/internals/Delay.hpp
index 8f4b758b..0dc5fb21 100644
--- a/src/server/internals/Delay.hpp
+++ b/src/server/internals/Delay.hpp
@@ -39,7 +39,7 @@ public:
 	          BufferFactory&      bufs,
 	          const Raul::Symbol& symbol,
 	          bool                polyphonic,
-	          PatchImpl*          parent,
+	          GraphImpl*          parent,
 	          SampleRate          srate);
 
 	~DelayNode();
diff --git a/src/server/internals/Note.cpp b/src/server/internals/Note.cpp
index 00ab0835..a373d4de 100644
--- a/src/server/internals/Note.cpp
+++ b/src/server/internals/Note.cpp
@@ -24,10 +24,10 @@
 
 #include "Buffer.hpp"
 #include "Driver.hpp"
+#include "GraphImpl.hpp"
 #include "InputPort.hpp"
 #include "InternalPlugin.hpp"
 #include "OutputPort.hpp"
-#include "PatchImpl.hpp"
 #include "ProcessContext.hpp"
 #include "ingen_config.h"
 #include "internals/Note.hpp"
@@ -50,7 +50,7 @@ NoteNode::NoteNode(InternalPlugin*     plugin,
                    BufferFactory&      bufs,
                    const Raul::Symbol& symbol,
                    bool                polyphonic,
-                   PatchImpl*          parent,
+                   GraphImpl*          parent,
                    SampleRate          srate)
 	: BlockImpl(plugin, symbol, polyphonic, parent, srate)
 	, _voices(new Raul::Array<Voice>(_polyphony))
diff --git a/src/server/internals/Note.hpp b/src/server/internals/Note.hpp
index 290908e8..dbdc59e7 100644
--- a/src/server/internals/Note.hpp
+++ b/src/server/internals/Note.hpp
@@ -42,7 +42,7 @@ public:
 	         BufferFactory&      bufs,
 	         const Raul::Symbol& symbol,
 	         bool                polyphonic,
-	         PatchImpl*          parent,
+	         GraphImpl*          parent,
 	         SampleRate          srate);
 
 	~NoteNode();
diff --git a/src/server/internals/Trigger.cpp b/src/server/internals/Trigger.cpp
index 31943425..2c353636 100644
--- a/src/server/internals/Trigger.cpp
+++ b/src/server/internals/Trigger.cpp
@@ -45,7 +45,7 @@ TriggerNode::TriggerNode(InternalPlugin*     plugin,
                          BufferFactory&      bufs,
                          const Raul::Symbol& symbol,
                          bool                polyphonic,
-                         PatchImpl*          parent,
+                         GraphImpl*          parent,
                          SampleRate          srate)
 	: BlockImpl(plugin, symbol, false, parent, srate)
 	, _learning(false)
diff --git a/src/server/internals/Trigger.hpp b/src/server/internals/Trigger.hpp
index 750cd287..b9ae4849 100644
--- a/src/server/internals/Trigger.hpp
+++ b/src/server/internals/Trigger.hpp
@@ -45,7 +45,7 @@ public:
 	            BufferFactory&      bufs,
 	            const Raul::Symbol& symbol,
 	            bool                polyphonic,
-	            PatchImpl*          parent,
+	            GraphImpl*          parent,
 	            SampleRate          srate);
 
 	void process(ProcessContext& context);
diff --git a/src/server/wscript b/src/server/wscript
index 9664545a..b6ec6e98 100644
--- a/src/server/wscript
+++ b/src/server/wscript
@@ -14,6 +14,7 @@ def build(bld):
             EdgeImpl.cpp
             Engine.cpp
             EventWriter.cpp
+            GraphImpl.cpp
             GraphObjectImpl.cpp
             InputPort.cpp
             InternalPlugin.cpp
@@ -21,14 +22,13 @@ def build(bld):
             LV2Info.cpp
             LV2Plugin.cpp
             OutputPort.cpp
-            PatchImpl.cpp
             PortImpl.cpp
             PostProcessor.cpp
             PreProcessor.cpp
             Worker.cpp
             events/Connect.cpp
             events/CreateBlock.cpp
-            events/CreatePatch.cpp
+            events/CreateGraph.cpp
             events/CreatePort.cpp
             events/Delete.cpp
             events/Delta.cpp
diff --git a/tests/connect_disconnect_node_node.ttl b/tests/connect_disconnect_node_node.ttl
index dba10924..7ea9c3c8 100644
--- a/tests/connect_disconnect_node_node.ttl
+++ b/tests/connect_disconnect_node_node.ttl
@@ -6,7 +6,7 @@
 	a patch:Put ;
 	patch:subject <ingen:root/node1> ;
 	patch:body [
-		a ingen:Node ;
+		a ingen:Block ;
 		ingen:prototype <http://drobilla.net/plugins/mda/Shepard>
 	] .
 
@@ -14,7 +14,7 @@
 	a patch:Put ;
 	patch:subject <ingen:root/node2> ;
 	patch:body [
-		a ingen:Node ;
+		a ingen:Block ;
 		ingen:prototype <http://drobilla.net/plugins/mda/Shepard>
 	] .
 
diff --git a/tests/connect_disconnect_node_patch.ttl b/tests/connect_disconnect_node_patch.ttl
index 038e1dba..e6403354 100644
--- a/tests/connect_disconnect_node_patch.ttl
+++ b/tests/connect_disconnect_node_patch.ttl
@@ -6,7 +6,7 @@
 	a patch:Put ;
 	patch:subject <ingen:root/node> ;
 	patch:body [
-		a ingen:Node ;
+		a ingen:Block ;
 		ingen:prototype <http://drobilla.net/plugins/mda/Shepard>
 	] .
 
diff --git a/tests/create_delete_node.ttl b/tests/create_delete_node.ttl
index 1d43bbce..8993e44b 100644
--- a/tests/create_delete_node.ttl
+++ b/tests/create_delete_node.ttl
@@ -6,7 +6,7 @@
 	a patch:Put ;
 	patch:subject <ingen:root/node> ;
 	patch:body [
-		a ingen:Node ;
+		a ingen:Block ;
 		ingen:prototype <http://drobilla.net/plugins/mda/Shepard>
 	] .
 
diff --git a/tests/create_delete_patch.ttl b/tests/create_delete_patch.ttl
index b0439dca..a3ef906c 100644
--- a/tests/create_delete_patch.ttl
+++ b/tests/create_delete_patch.ttl
@@ -6,7 +6,7 @@
 	a patch:Put ;
 	patch:subject <ingen:root/sub> ;
 	patch:body [
-		a ingen:Patch ;
+		a ingen:Graph ;
 	] .
 
 <msg1>
diff --git a/tests/disconnect_all_node.ttl b/tests/disconnect_all_node.ttl
index 9c1d425c..7d71705c 100644
--- a/tests/disconnect_all_node.ttl
+++ b/tests/disconnect_all_node.ttl
@@ -6,7 +6,7 @@
 	a patch:Put ;
 	patch:subject <ingen:root/node1> ;
 	patch:body [
-		a ingen:Node ;
+		a ingen:Block ;
 		ingen:prototype <http://drobilla.net/plugins/mda/Shepard>
 	] .
 
@@ -14,7 +14,7 @@
 	a patch:Put ;
 	patch:subject <ingen:root/node2> ;
 	patch:body [
-		a ingen:Node ;
+		a ingen:Block ;
 		ingen:prototype <http://drobilla.net/plugins/mda/Shepard>
 	] .
 
diff --git a/tests/get_node.ttl b/tests/get_node.ttl
index b1e0468c..44ca1641 100644
--- a/tests/get_node.ttl
+++ b/tests/get_node.ttl
@@ -6,7 +6,7 @@
 	a patch:Put ;
 	patch:subject <ingen:root/node> ;
 	patch:body [
-		a ingen:Node ;
+		a ingen:Block ;
 		ingen:prototype <http://drobilla.net/plugins/mda/Shepard>
 	] .
 
diff --git a/tests/get_patch.ttl b/tests/get_patch.ttl
index 158408ff..5d2eb737 100644
--- a/tests/get_patch.ttl
+++ b/tests/get_patch.ttl
@@ -6,14 +6,14 @@
 	a patch:Put ;
 	patch:subject <ingen:root/sub> ;
 	patch:body [
-		a ingen:Patch
+		a ingen:Graph
 	] .
 
 <msg1>
 	a patch:Put ;
 	patch:subject <ingen:root/sub/node1> ;
 	patch:body [
-		a ingen:Node ;
+		a ingen:Block ;
 		ingen:prototype <http://drobilla.net/plugins/mda/Shepard>
 	] .
 
@@ -21,7 +21,7 @@
 	a patch:Put ;
 	patch:subject <ingen:root/sub/node2> ;
 	patch:body [
-		a ingen:Node ;
+		a ingen:Block ;
 		ingen:prototype <http://drobilla.net/plugins/mda/Combo>
 	] .
 
diff --git a/tests/ingen_test.cpp b/tests/ingen_test.cpp
index 68981078..62ee502a 100644
--- a/tests/ingen_test.cpp
+++ b/tests/ingen_test.cpp
@@ -31,7 +31,6 @@
 #include "raul/Path.hpp"
 #include "raul/SharedPtr.hpp"
 #include "raul/Thread.hpp"
-#include "raul/log.hpp"
 
 #include "serd/serd.h"
 #include "sord/sordmm.hpp"
@@ -67,7 +66,7 @@ class TestClient : public AtomSink {
 class TestClient : public Interface
 {
 public:
-	TestClient() {}
+	TestClient(Log& log) : _log(log) {}
 	~TestClient() {}
 
 	Raul::URI uri() const { return Raul::URI("ingen:testClient"); }
@@ -108,16 +107,19 @@ public:
 
 	void response(int32_t id, Status status, const std::string& subject) {
 		if (status) {
-			Raul::error(Raul::fmt("error on message %1%: %2% (%3%)\n")
-			            % id % ingen_status_string(status) % subject);
+			_log.error(Raul::fmt("error on message %1%: %2% (%3%)\n")
+			           % id % ingen_status_string(status) % subject);
 			exit(EXIT_FAILURE);
 		}
 	}
 
 	void error(const std::string& msg) {
-		Raul::error(Raul::fmt("error: %1%\n") % msg);
+		_log.error(Raul::fmt("error: %1%\n") % msg);
 		exit(EXIT_FAILURE);
 	}
+
+private:
+	Log& _log;
 };
 
 
@@ -144,7 +146,7 @@ main(int argc, char** argv)
 
 	// Create world
 	try {
-		world = new World(argc, argv, NULL, NULL);
+		world = new World(argc, argv, NULL, NULL, NULL);
 	} catch (std::exception& e) {
 		cout << "ingen: " << e.what() << endl;
 		return EXIT_FAILURE;
@@ -186,8 +188,11 @@ main(int argc, char** argv)
 	const std::string cmds_file_path = argv[2];
 
 	// AtomReader to read commands from a file and send them to engine
-	AtomReader atom_reader(
-		world->uri_map(), world->uris(), world->forge(), *world->interface().get());
+	AtomReader atom_reader(world->uri_map(),
+	                       world->uris(),
+	                       world->log(),
+	                       world->forge(),
+	                       *world->interface().get());
 
 	// AtomWriter to serialise responses from the engine
 	/*
@@ -195,7 +200,7 @@ main(int argc, char** argv)
 	SharedPtr<AtomWriter> atom_writer(
 		new AtomWriter(world->uri_map(), world->uris(), client));
 	*/
-	SharedPtr<Interface> client(new TestClient());
+	SharedPtr<Interface> client(new TestClient(world->log()));
 
 	world->interface()->set_respondee(client);
 	world->engine()->register_client(Raul::URI("ingen:testClient"),
diff --git a/tests/move_node.ttl b/tests/move_node.ttl
index 077069cb..8135b4a5 100644
--- a/tests/move_node.ttl
+++ b/tests/move_node.ttl
@@ -6,7 +6,7 @@
 	a patch:Put ;
 	patch:subject <ingen:root/node> ;
 	patch:body [
-		a ingen:Node ;
+		a ingen:Block ;
 		ingen:prototype <http://drobilla.net/plugins/mda/Shepard>
 	] .
 
diff --git a/tests/poly.ttl b/tests/poly.ttl
index b5a8b3c5..fc40bbc9 100644
--- a/tests/poly.ttl
+++ b/tests/poly.ttl
@@ -6,7 +6,7 @@
 	a patch:Put ;
 	patch:subject <ingen:root/node> ;
 	patch:body [
-		a ingen:Node ;
+		a ingen:Block ;
 		ingen:prototype <http://drobilla.net/plugins/mda/Shepard>
 	] .