diff --git a/include/remote_rom/backend_base.h b/include/remote_rom/backend_base.h
index 2d8b786..b715467 100644
--- a/include/remote_rom/backend_base.h
+++ b/include/remote_rom/backend_base.h
@@ -22,8 +22,8 @@ namespace Remote_rom {
 	struct Backend_client_base;
 
 	class Exception : public ::Genode::Exception { };
-	Backend_server_base &backend_init_server();
-	Backend_client_base &backend_init_client();
+	Backend_server_base &backend_init_server(Genode::Env &env, Genode::Allocator &alloc);
+	Backend_client_base &backend_init_client(Genode::Env &env, Genode::Allocator &alloc);
 };
 
 struct Remote_rom::Backend_server_base
diff --git a/src/lib/remote_rom/backend/nic_ip/backend.cc b/src/lib/remote_rom/backend/nic_ip/backend.cc
index 756ab5c..48e5dad 100644
--- a/src/lib/remote_rom/backend/nic_ip/backend.cc
+++ b/src/lib/remote_rom/backend/nic_ip/backend.cc
@@ -7,6 +7,7 @@
 #include <base/env.h>
 #include <base/exception.h>
 #include <base/log.h>
+#include <base/attached_rom_dataspace.h>
 
 #include <backend_base.h>
 
@@ -16,8 +17,6 @@
 #include <net/ethernet.h>
 #include <net/ipv4.h>
 
-#include <os/config.h>
-
 namespace Remote_rom {
 	bool verbose = false;
 	using  Genode::size_t;
@@ -305,9 +304,9 @@ class Remote_rom::Backend_base
 		}
 
 	public:
-		explicit Backend_base(Genode::Allocator &alloc, HANDLER &handler)
+		explicit Backend_base(Genode::Env &env, Genode::Allocator &alloc, HANDLER &handler)
 		:
-			_tx_block_alloc(&alloc), _nic(&_tx_block_alloc, BUF_SIZE, BUF_SIZE),
+			_tx_block_alloc(&alloc), _nic(env, &_tx_block_alloc, BUF_SIZE, BUF_SIZE),
 			_rx_thread(_nic, handler, _accept_ip)
 		{
 			/* start dispatcher thread */
@@ -316,9 +315,11 @@ class Remote_rom::Backend_base
 			/* store mac address */
 			_mac_address = _nic.mac_address();
 
+			Genode::Attached_rom_dataspace config = {env, "config"};
+
 			try {
 				char ip_string[15];
-				Genode::Xml_node remoterom = Genode::config()->xml_node().sub_node("remote_rom");
+				Genode::Xml_node remoterom = config.xml().sub_node("remote_rom");
 				remoterom.attribute("src").value(ip_string, sizeof(ip_string));
 				_src_ip = Ipv4_packet::ip_from_string(ip_string);
 
@@ -358,12 +359,8 @@ class Remote_rom::Backend_base
 class Remote_rom::Backend_server : public Backend_server_base, public Backend_base<Backend_server>
 {
 	private:
-		static Backend_server_base* _instance;
 		Rom_forwarder_base         *_forwarder;
 
-		Backend_server(Genode::Allocator &alloc) : Backend_base(alloc, *this), _forwarder(nullptr)
-		{	}
-
 		void send_data()
 		{
 			if (!_forwarder) return;
@@ -390,17 +387,8 @@ class Remote_rom::Backend_server : public Backend_server_base, public Backend_ba
 		}
 
 	public:
-		static Backend_server_base &instance()
-		{
-			if (!_instance) {
-				_instance = new (env()->heap()) Backend_server(*env()->heap());
-
-				if (!_instance)
-					throw Exception();
-			}
-
-			return *_instance;
-		}
+		Backend_server(Genode::Env &env, Genode::Allocator &alloc) : Backend_base(env, alloc, *this), _forwarder(nullptr)
+		{	}
 
 		void register_forwarder(Rom_forwarder_base *forwarder)
 		{
@@ -451,14 +439,10 @@ class Remote_rom::Backend_server : public Backend_server_base, public Backend_ba
 class Remote_rom::Backend_client : public Backend_client_base, public Backend_base<Backend_client>
 {
 	private:
-		static Backend_client_base *_instance;
 		Rom_receiver_base          *_receiver;
 		char                       *_write_ptr;
 		size_t                     _buf_size;
 
-		Backend_client(Genode::Allocator &alloc) : Backend_base(alloc, *this), _receiver(nullptr), _write_ptr(nullptr), _buf_size(0)
-		{
-		}
 
 		void write(char *data, size_t offset, size_t size)
 		{
@@ -472,16 +456,8 @@ class Remote_rom::Backend_client : public Backend_client_base, public Backend_ba
 		}
 
 	public:
-		static Backend_client_base &instance()
+		Backend_client(Genode::Env &env, Genode::Allocator &alloc) : Backend_base(env, alloc, *this), _receiver(nullptr), _write_ptr(nullptr), _buf_size(0)
 		{
-			if (!_instance) {
-				_instance = new (env()->heap()) Backend_client(*env()->heap());
-
-				if (!_instance)
-					throw Exception();
-			}
-
-			return *_instance;
 		}
 
 		void register_receiver(Rom_receiver_base *receiver)
@@ -564,15 +540,14 @@ class Remote_rom::Backend_client : public Backend_client_base, public Backend_ba
 		}
 };
 
-Remote_rom::Backend_server_base *Remote_rom::Backend_server::_instance = nullptr;
-Remote_rom::Backend_client_base *Remote_rom::Backend_client::_instance = nullptr;
-
-Remote_rom::Backend_server_base &Remote_rom::backend_init_server()
+Remote_rom::Backend_server_base &Remote_rom::backend_init_server(Genode::Env &env, Genode::Allocator &alloc)
 {
-	return Backend_server::instance();
+	static Backend_server backend(env, alloc);
+	return backend;
 }
 
-Remote_rom::Backend_client_base &Remote_rom::backend_init_client()
+Remote_rom::Backend_client_base &Remote_rom::backend_init_client(Genode::Env &env, Genode::Allocator &alloc)
 {
-	return Backend_client::instance();
+	static Backend_client backend(env, alloc);
+	return backend;
 }
diff --git a/src/proxy/remote_rom/client/main.cc b/src/proxy/remote_rom/client/main.cc
index 28345f3..c3d2a5b 100644
--- a/src/proxy/remote_rom/client/main.cc
+++ b/src/proxy/remote_rom/client/main.cc
@@ -26,11 +26,11 @@
 #include <base/rpc_server.h>
 #include <root/component.h>
 
-#include <os/attached_ram_dataspace.h>
+#include <base/attached_ram_dataspace.h>
+#include <base/attached_rom_dataspace.h>
 #include <rom_session/rom_session.h>
 
 #include <base/component.h>
-#include <os/config.h>
 
 #include <backend_base.h>
 
@@ -44,8 +44,6 @@ namespace Remote_rom {
 	struct Main;
 	struct Read_buffer;
 
-	static char remotename[255];
-
 	typedef Genode::List<Session_component> Session_list;
 };
 
@@ -104,7 +102,7 @@ class Remote_rom::Session_component : public Genode::Rpc_object<Genode::Rom_sess
 			if (!_ram_ds.is_constructed()
 			 || _buffer.content_size() > _ram_ds->size()) {
 
-				_ram_ds.construct(&_env.ram(), _buffer.content_size());
+				_ram_ds.construct(_env.ram(), _env.rm(), _buffer.content_size());
 			}
 
 			char             *dst = _ram_ds->local_addr<char>();
@@ -170,16 +168,25 @@ struct Remote_rom::Main : public Remote_rom::Read_buffer, public Remote_rom::Rom
 	Genode::Constructible<Genode::Attached_ram_dataspace> _ds;
 	size_t                                                _ds_content_size;
 
+	Genode::Attached_rom_dataspace _config = { env, "config" };
+
 	Backend_client_base &_backend;
 
-	Main(Genode::Env &env) : env(env), _ds_content_size(1024), _backend(backend_init_client())
+	char remotename[255];
+
+	Main(Genode::Env &env) : env(env), _ds_content_size(1024), _backend(backend_init_client(env, heap))
 	{
+		try {
+			Genode::Xml_node remote_rom = _config.xml().sub_node("remote_rom");
+			remote_rom.attribute("name").value(remotename, sizeof(remotename));
+		} catch (...) {
+			Genode::error("No ROM module configured!");
+		}
+
 		env.parent().announce(env.ep().manage(remote_rom_root));
 
 		/* initialise backend */
 		_backend.register_receiver(this);
-		
-//		_ds.construct(Genode::env()->ram_session(), _ds_content_size);
 	}
 
 	const char* module_name() const { return remotename; }
@@ -191,7 +198,7 @@ struct Remote_rom::Main : public Remote_rom::Read_buffer, public Remote_rom::Rom
 
 		// TODO (optional) implement double buffering
 		if (!_ds.is_constructed() || _ds_content_size > _ds->size())
-			_ds.construct(&env.ram(), _ds_content_size);
+			_ds.construct(env.ram(), env.rm(), _ds_content_size);
 
 		// TODO set write lock
 
@@ -216,7 +223,7 @@ struct Remote_rom::Main : public Remote_rom::Read_buffer, public Remote_rom::Rom
 		else {
 			/* transfer default content if set */
 			try {
-				Genode::Xml_node default_content = Genode::config()->xml_node().sub_node("remote_rom").sub_node("default");
+				Genode::Xml_node default_content = _config.xml().sub_node("remote_rom").sub_node("default");
 				return default_content.content_size();
 			} catch (...) { }
 		}
@@ -234,7 +241,7 @@ struct Remote_rom::Main : public Remote_rom::Read_buffer, public Remote_rom::Rom
 		else {
 			/* transfer default content if set */
 			try {
-				Genode::Xml_node default_content = Genode::config()->xml_node().sub_node("remote_rom").sub_node("default");
+				Genode::Xml_node default_content = _config.xml().sub_node("remote_rom").sub_node("default");
 				size_t const len = Genode::min(dst_len, default_content.content_size());
 				Genode::memcpy(dst, default_content.content_base(), len);
 				return len;
@@ -248,13 +255,6 @@ namespace Component {
 	Genode::size_t stack_size()    { return 2*1024*sizeof(long); }
 	void construct(Genode::Env &env)
 	{
-		try {
-			Genode::Xml_node remote_rom = Genode::config()->xml_node().sub_node("remote_rom");
-			remote_rom.attribute("name").value(Remote_rom::remotename, sizeof(Remote_rom::remotename));
-		} catch (...) {
-			Genode::error("No ROM module configured!");
-		}
-
 		static Remote_rom::Main main(env);
 	}
 }
diff --git a/src/proxy/remote_rom/server/main.cc b/src/proxy/remote_rom/server/main.cc
index fd43201..90bef18 100644
--- a/src/proxy/remote_rom/server/main.cc
+++ b/src/proxy/remote_rom/server/main.cc
@@ -19,12 +19,12 @@
 
 #include <base/log.h>
 #include <base/env.h>
+#include <base/heap.h>
 
 #include <backend_base.h>
 
 #include <base/component.h>
-#include <os/config.h>
-#include <os/attached_rom_dataspace.h>
+#include <base/attached_rom_dataspace.h>
 
 namespace Remote_rom {
 	using Genode::size_t;
@@ -44,7 +44,10 @@ struct Remote_rom::Rom_forwarder : Rom_forwarder_base
 		Attached_rom_dataspace &_rom;
 		Backend_server_base    &_backend;
 
-		Rom_forwarder(Attached_rom_dataspace &rom, Backend_server_base &backend) : _rom(rom), _backend(backend)
+		Attached_rom_dataspace &_config;
+
+		Rom_forwarder(Attached_rom_dataspace &rom, Backend_server_base &backend, Attached_rom_dataspace &config)
+			: _rom(rom), _backend(backend), _config(config)
 		{
 			_backend.register_forwarder(this);
 
@@ -75,7 +78,7 @@ struct Remote_rom::Rom_forwarder : Rom_forwarder_base
 			}
 			else {
 				try {
-					Genode::Xml_node default_content = Genode::config()->xml_node().sub_node("remote_rom").sub_node("default");
+					Genode::Xml_node default_content = _config.xml().sub_node("remote_rom").sub_node("default");
 					return default_content.content_size();
 				} catch (...) { }
 			}
@@ -92,7 +95,7 @@ struct Remote_rom::Rom_forwarder : Rom_forwarder_base
 			else {
 				/* transfer default content if set */
 				try {
-					Genode::Xml_node default_content = Genode::config()->xml_node().sub_node("remote_rom").sub_node("default");
+					Genode::Xml_node default_content = _config.xml().sub_node("remote_rom").sub_node("default");
 					size_t const len = Genode::min(dst_len, default_content.content_size()-offset);
 					Genode::memcpy(dst, default_content.content_base() + offset, len);
 					return len;
@@ -105,16 +108,19 @@ struct Remote_rom::Rom_forwarder : Rom_forwarder_base
 
 struct Remote_rom::Main
 {
-	Genode::Entrypoint    &_ep;
+	Genode::Env    &_env;
+	Genode::Heap    _heap   = { &_env.ram(), &_env.rm() };
+	Attached_rom_dataspace _config = { _env, "config" };
+
 	Attached_rom_dataspace _rom;
 	Rom_forwarder          _forwarder;
 
-	Genode::Signal_handler<Rom_forwarder> _dispatcher = { _ep, _forwarder, &Rom_forwarder::update };
+	Genode::Signal_handler<Rom_forwarder> _dispatcher = { _env.ep(), _forwarder, &Rom_forwarder::update };
 
-	Main(Genode::Entrypoint &ep)
-		: _ep(ep),
-	     _rom(modulename),
-	     _forwarder(_rom, backend_init_server())
+	Main(Genode::Env &env)
+		: _env(env),
+	     _rom(env, modulename),
+	     _forwarder(_rom, backend_init_server(env, _heap), _config)
 	{
 		/* register update dispatcher */
 		_rom.sigh(_dispatcher);
@@ -123,10 +129,13 @@ struct Remote_rom::Main
 
 namespace Component {
 	Genode::size_t stack_size()    { return 2*1024*sizeof(long); }
+
+
 	void construct(Genode::Env &env)
 	{
+		Genode::Attached_rom_dataspace config = { env, "config" };
 		try {
-			Genode::Xml_node remote_rom = Genode::config()->xml_node().sub_node("remote_rom");
+			Genode::Xml_node remote_rom = config.xml().sub_node("remote_rom");
 			if (remote_rom.has_attribute("localname"))
 				remote_rom.attribute("localname").value(Remote_rom::modulename, sizeof(Remote_rom::modulename));
 			else
@@ -140,6 +149,6 @@ namespace Component {
 			Genode::error("No ROM module configured!");
 		}
 
-		static Remote_rom::Main main(env.ep());
+		static Remote_rom::Main main(env);
 	}
 }