chore: import VIATRA source

Make our modifications more maintainable by editing the source code directly instead of using reflection.
author: Kristóf Marussy <kristof@marussy.com> 2023-08-19 02:31:57 +0200
committer: Kristóf Marussy <kristof@marussy.com> 2023-08-19 02:31:57 +0200
commit: 9adbb3d49899a87b3026c11cb4ba3ff77f4fb75b (patch)
tree: fad77963c1dc9028b0a767ac3ad69a174c8eb8c6 /subprojects/viatra-runtime
parent: feat: predicate semantics (diff)
download: refinery-9adbb3d49899a87b3026c11cb4ba3ff77f4fb75b.tar.gz
refinery-9adbb3d49899a87b3026c11cb4ba3ff77f4fb75b.tar.zst
refinery-9adbb3d49899a87b3026c11cb4ba3ff77f4fb75b.zip
95 files changed, 10085 insertions, 0 deletions
diff --git a/subprojects/viatra-runtime/about.html b/subprojects/viatra-runtime/about.html
new file mode 100644
index 00000000..d1d5593a
--- /dev/null
+++ b/subprojects/viatra-runtime/about.html
@@ -0,0 +1,26 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
+<html>
+<!--
+  Copyright (c) 2017, Eclipse.org Foundation, Inc.
+  SPDX-License-Identifier: LicenseRef-EPL-Steward
+-->
+<head>
+<title>About</title>
+<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+<p>March 18, 2019</p>
+<h3>License</h3>
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/org/documents/epl-v20.php">http://www.eclipse.org/legal/epl-v20.html</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+</body>
+</html>
diff --git a/subprojects/viatra-runtime/build.gradle.kts b/subprojects/viatra-runtime/build.gradle.kts
new file mode 100644
index 00000000..5d6e3de6
--- /dev/null
+++ b/subprojects/viatra-runtime/build.gradle.kts
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+plugins {
+        id("tools.refinery.gradle.java-library")
+}
+dependencies {
+        api(project(":refinery-viatra-runtime-base"))
+        api(libs.ecore)
+        implementation(libs.eclipse)
+        implementation(libs.emf)
+        implementation(libs.slf4j.log4j)
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/IExtensions.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/IExtensions.java
new file mode 100644
index 00000000..d5e0d51f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/IExtensions.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime;
+/**
+ * Interface for storing string constants related to VIATRA Query's extension points.
+ *
+ * @author Istvan Rath
+ *
+ */
+public interface IExtensions {
+    public static final String QUERY_SPECIFICATION_EXTENSION_POINT_ID = ViatraQueryRuntimePlugin.PLUGIN_ID + ".queryspecification";
+    public static final String INJECTOREXTENSIONID = ViatraQueryRuntimePlugin.PLUGIN_ID + ".injectorprovider";
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/ViatraQueryRuntimePlugin.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/ViatraQueryRuntimePlugin.java
new file mode 100644
index 00000000..5fbcdad0
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/ViatraQueryRuntimePlugin.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime;
+import org.eclipse.core.runtime.Plugin;
+import tools.refinery.viatra.runtime.internal.ExtensionBasedSurrogateQueryLoader;
+import tools.refinery.viatra.runtime.internal.ExtensionBasedSystemDefaultBackendLoader;
+import tools.refinery.viatra.runtime.registry.ExtensionBasedQuerySpecificationLoader;
+import org.osgi.framework.BundleContext;
+/**
+ * The activator class controls the plug-in life cycle
+ */
+public class ViatraQueryRuntimePlugin extends Plugin {
+    public static final String PLUGIN_ID = "tools.refinery.viatra.runtime";
+    @Override
+    public void start(BundleContext context) throws Exception {
+        super.start(context);
+        ExtensionBasedSurrogateQueryLoader.instance().loadKnownSurrogateQueriesIntoRegistry();
+        ExtensionBasedQuerySpecificationLoader.getInstance().loadRegisteredQuerySpecificationsIntoRegistry();
+        ExtensionBasedSystemDefaultBackendLoader.instance().loadKnownBackends();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/AdvancedViatraQueryEngine.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/AdvancedViatraQueryEngine.java
new file mode 100644
index 00000000..21e7dfa3
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/AdvancedViatraQueryEngine.java
@@ -0,0 +1,368 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import java.lang.reflect.InvocationTargetException;
+import java.util.concurrent.Callable;
+import tools.refinery.viatra.runtime.api.scope.QueryScope;
+import tools.refinery.viatra.runtime.emf.EMFScope;
+import tools.refinery.viatra.runtime.internal.apiimpl.ViatraQueryEngineImpl;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.backend.IMatcherCapability;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackend;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendFactory;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+/**
+ * Advanced interface to a VIATRA incremental evaluation engine.
+ * 
+ * <p>
+ * You can create a new, private, unmanaged {@link AdvancedViatraQueryEngine} instance using
+ * {@link #createUnmanagedEngine(QueryScope)}. Additionally, you can access the advanced interface on any
+ * {@link ViatraQueryEngine} by {@link AdvancedViatraQueryEngine#from(ViatraQueryEngine)}.
+ * 
+ * <p>
+ * While the default interface {@link ViatraQueryEngine}, is suitable for most users, this advanced interface provides more
+ * control over the engine. The most important added functionality is the following:
+ * <ul>
+ * <li>You can have tighter control over the lifecycle of the engine, if you create a private, unmanaged engine
+ * instance. For instance, a (non-managed) engine can be disposed in order to detach from the EMF model and stop
+ * listening on update notifications. The indexes built previously in the engine can then be garbage collected, even if
+ * the model itself is retained. Total lifecycle control is only available for private, unmanaged engines (created using
+ * {@link #createUnmanagedEngine(QueryScope)}); a managed engine (obtained via {@link ViatraQueryEngine#on(QueryScope)}) is
+ * shared among clients and can not be disposed or wiped.
+ * <li>You can add and remove listeners to receive notification when the model or the match sets change.
+ * <li>You can add and remove listeners to receive notification on engine lifecycle events, such as creation of new
+ * matchers. For instance, if you explicitly share a private, unmanaged engine between multiple sites, you should
+ * register a callback using {@link #addLifecycleListener(ViatraQueryEngineLifecycleListener)} to learn when another client
+ * has called the destructive methods {@link #dispose()} or {@link #wipe()}.
+ * </ul>
+ * 
+ * @author Bergmann Gabor
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public abstract class AdvancedViatraQueryEngine extends ViatraQueryEngine {
+   
+    /**
+     * Creates a new unmanaged VIATRA Query engine to evaluate queries over a given scope specified by an {@link QueryScope}.
+     * 
+     * <p> Repeated invocations will return different instances, so other clients are unable to independently access 
+     * and influence the returned engine. Note that unmanaged engines do not benefit from some performance improvements 
+     * that stem from sharing incrementally maintained indices and caches between multiple clients using the same managed 
+     * engine instance.
+     * 
+     * <p>
+     * Client is responsible for the lifecycle of the returned engine, hence the usage of the advanced interface
+     * {@link AdvancedViatraQueryEngine}.
+     * 
+     * <p>
+     * The match set of any patterns will be incrementally refreshed upon updates from this scope.
+     * 
+     * @param scope 
+     *          the scope of query evaluation; the definition of the set of model elements that this engine is operates on. 
+     *          Provide e.g. a {@link EMFScope} for evaluating queries on an EMF model.
+     * @return the advanced interface to a newly created unmanaged engine
+     * @since 0.9
+     */
+    public static AdvancedViatraQueryEngine createUnmanagedEngine(QueryScope scope) {
+        return new ViatraQueryEngineImpl(null, scope);
+    }
+    
+    /**
+     * Creates a new unmanaged VIATRA Query engine to evaluate queries over a given scope specified by an {@link QueryScope}.
+     * 
+     * <p> Repeated invocations will return different instances, so other clients are unable to independently access 
+     * and influence the returned engine. Note that unmanaged engines do not benefit from some performance improvements 
+     * that stem from sharing incrementally maintained indices and caches between multiple clients using the same managed 
+     * engine instance.
+     * 
+     * <p>
+     * Client is responsible for the lifecycle of the returned engine, hence the usage of the advanced interface
+     * {@link AdvancedViatraQueryEngine}.
+     * 
+     * <p>
+     * The match set of any patterns will be incrementally refreshed upon updates from this scope.
+     * 
+     * @param scope 
+     *      the scope of query evaluation; the definition of the set of model elements that this engine is operates on. 
+     *      Provide e.g. a {@link EMFScope} for evaluating queries on an EMF model.
+     * @return the advanced interface to a newly created unmanaged engine
+     * @since 1.4
+     */
+    public static AdvancedViatraQueryEngine createUnmanagedEngine(QueryScope scope, ViatraQueryEngineOptions options) {
+        return new ViatraQueryEngineImpl(null, scope, options);
+    }
+    /**
+     * Provides access to a given existing engine through the advanced interface.
+     * 
+     * <p>
+     * Caveat: if the referenced engine is managed (i.e. created via {@link ViatraQueryEngine#on(QueryScope)}), the advanced
+     * methods {@link #dispose()} and {@link #wipe()} will not be allowed.
+     * 
+     * @param engine
+     *            the engine to access using the advanced interface
+     * @return a reference to the same engine conforming to the advanced interface
+     */
+    public static AdvancedViatraQueryEngine from(ViatraQueryEngine engine) {
+        return (AdvancedViatraQueryEngine) engine;
+    }
+    /**
+     * Add an engine lifecycle listener to this engine instance.
+     * 
+     * @param listener
+     *            the {@link ViatraQueryEngineLifecycleListener} that should listen to lifecycle events from this engine
+     */
+    public abstract void addLifecycleListener(ViatraQueryEngineLifecycleListener listener);
+    /**
+     * Remove an existing lifecycle listener from this engine instance.
+     * 
+     * @param listener
+     *            the {@link ViatraQueryEngineLifecycleListener} that should not listen to lifecycle events from this
+     *            engine anymore
+     */
+    public abstract void removeLifecycleListener(ViatraQueryEngineLifecycleListener listener);
+    /**
+     * Add an model update event listener to this engine instance (that fires its callbacks according to its
+     * notification level).
+     * 
+     * @param listener
+     *            the {@link ViatraQueryModelUpdateListener} that should listen to model update events from this engine.
+     */
+    public abstract void addModelUpdateListener(ViatraQueryModelUpdateListener listener);
+    /**
+     * Remove an existing model update event listener to this engine instance.
+     * 
+     * @param listener
+     *            the {@link ViatraQueryModelUpdateListener} that should not listen to model update events from this engine
+     *            anymore
+     */
+    public abstract void removeModelUpdateListener(ViatraQueryModelUpdateListener listener);
+    /**
+     * Registers low-level callbacks for match appearance and disappearance on this pattern matcher.
+     * 
+     * <p>
+     * <b>Caution: </b> This is a low-level callback that is invoked when the pattern matcher is not necessarily in a
+     * consistent state yet. Importantly, no model modification permitted during the callback. Most users should use the
+     * databinding support ({@link org.eclipse.viatra.addon.databinding.runtime.api.ViatraObservables ViatraObservables}) or the event-driven API
+     * ({@link org.eclipse.viatra.transformation.evm.api.EventDrivenVM EventDrivenVM}) instead.
+     * 
+     * <p>
+     * Performance note: expected to be much more efficient than polling at {@link #addCallbackAfterUpdates(Runnable)},
+     * but prone to "signal hazards", e.g. spurious match appearances that will disappear immediately afterwards.
+     * 
+     * <p>
+     * The callback can be unregistered via {@link #removeCallbackOnMatchUpdate(IMatchUpdateListener)}.
+     * 
+     * @param fireNow
+     *            if true, appearCallback will be immediately invoked on all current matches as a one-time effect. See
+     *            also {@link ViatraQueryMatcher#forEachMatch(IMatchProcessor)}.
+     * @param listener
+     *            the listener that will be notified of each new match that appears or disappears, starting from now.
+     * @param matcher
+     *            the {@link ViatraQueryMatcher} for which this listener should be active
+     */
+    public abstract <Match extends IPatternMatch> void addMatchUpdateListener(ViatraQueryMatcher<Match> matcher,
+            IMatchUpdateListener<? super Match> listener, boolean fireNow);
+    /**
+     * Remove an existing match update event listener to this engine instance.
+     * 
+     * @param matcher
+     *            the {@link ViatraQueryMatcher} for which this listener should not be active anymore
+     * @param listener
+     *            the {@link IMatchUpdateListener} that should not receive the callbacks anymore
+     */
+    public abstract <Match extends IPatternMatch> void removeMatchUpdateListener(ViatraQueryMatcher<Match> matcher,
+            IMatchUpdateListener<? super Match> listener);
+    
+    /**
+     * Access a pattern matcher based on a {@link IQuerySpecification}, overriding some of the default query evaluation hints. 
+     * Multiple calls may return the same matcher depending on the actual evaluation hints. 
+     * 
+     * <p> It is guaranteed that this method will always return a matcher instance which is functionally compatible 
+     *   with the requested functionality (see {@link IMatcherCapability}). 
+     *   Otherwise, the query evaluator is free to ignore any hints.
+     * 
+     * <p> For stateful query backends (Rete), hints may be effective only the first time a matcher is created.
+     * @param querySpecification a {@link IQuerySpecification} that describes a VIATRA query
+     * @return a pattern matcher corresponding to the specification
+     * @param optionalEvaluationHints additional / overriding options on query evaluation; passing null means default options associated with the query
+     * @throws ViatraQueryRuntimeException if the matcher could not be initialized
+     * @since 0.9
+     */
+    public abstract <Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> Matcher getMatcher(
+            IQuerySpecification<Matcher> querySpecification, 
+            QueryEvaluationHint optionalEvaluationHints);
+    /**
+     * Initializes matchers for a group of patterns as one step (optionally overriding some of the default query evaluation hints). 
+     * If some of the pattern matchers are already
+     * constructed in the engine, no task is performed for them.
+     * 
+     * <p>
+     * This preparation step has the advantage that it prepares pattern matchers for an arbitrary number of patterns in a
+     * single-pass traversal of the model. 
+     * This is typically more efficient than traversing the model each time an individual pattern matcher is initialized on demand. 
+     * The performance benefit only manifests itself if the engine is not in wildcard mode.
+     * 
+     * @param queryGroup a {@link IQueryGroup} identifying a set of VIATRA queries
+     * @param optionalEvaluationHints additional / overriding options on query evaluation; passing null means default options associated with each query
+     * @throws ViatraQueryRuntimeException
+     *             if there was an error in preparing the engine
+     * @since 0.9
+     */
+    public abstract void prepareGroup(IQueryGroup queryGroup, QueryEvaluationHint optionalEvaluationHints);
+ 
+    /**
+     * Indicates whether the engine is managed, i.e. the default engine assigned to the given scope root by
+     * {@link ViatraQueryEngine#on(QueryScope)}.
+     * 
+     * <p>
+     * If the engine is managed, there may be other clients using it, as all calls to
+     * {@link ViatraQueryEngine#on(QueryScope)} return the same managed engine instance for a given scope root. Therefore the
+     * destructive methods {@link #wipe()} and {@link #dispose()} are not allowed.
+     * 
+     * <p>
+     * On the other hand, if the engine is unmanaged (i.e. a private instance created using
+     * {@link #createUnmanagedEngine(QueryScope)}), then {@link #wipe()} and {@link #dispose()} can be called. If you
+     * explicitly share a private, unmanaged engine between multiple sites, register a callback using
+     * {@link #addLifecycleListener(ViatraQueryEngineLifecycleListener)} to learn when another client has called these
+     * destructive methods.
+     * 
+     * @return true if the engine is managed, and therefore potentially shared with other clients querying the same EMF
+     *         model
+     */
+    public abstract boolean isManaged();
+    /**
+     * Indicates whether the engine is in a tainted, inconsistent state due to some internal errors. If true, results
+     * are no longer reliable; engine should be disposed.
+     * 
+     * <p>
+     * The engine is in a tainted state if any of its internal processes report back a fatal error. The
+     * {@link ViatraQueryEngineLifecycleListener} interface provides a callback method for entering the tainted state.
+     * 
+     * @return the tainted state
+     */
+    public abstract boolean isTainted();
+    /**
+     * Discards any pattern matcher caches and forgets known patterns. The base index built directly on the underlying
+     * EMF model, however, is kept in memory to allow reuse when new pattern matchers are built. Use this method if you
+     * have e.g. new versions of the same patterns, to be matched on the same model.
+     * 
+     * <p>
+     * Matcher objects will continue to return stale results. If no references are retained to the matchers, they can
+     * eventually be GC'ed.
+     * <p>
+     * Disallowed if the engine is managed (see {@link #isManaged()}), as there may be other clients using it.
+     * <p>
+     * If you explicitly share a private, unmanaged engine between multiple sites, register a callback using
+     * {@link #addLifecycleListener(ViatraQueryEngineLifecycleListener)} to learn when another client has called this
+     * destructive method.
+     * 
+     * @throws UnsupportedOperationException
+     *             if engine is managed
+     */
+    public abstract void wipe();
+    /**
+     * Completely disconnects and dismantles the engine. Cannot be reversed.
+     * <p>
+     * Matcher objects will continue to return stale results. If no references are retained to the matchers or the
+     * engine, they can eventually be GC'ed, and they won't block the EMF model from being GC'ed anymore.
+     * <p>
+     * The base indexer (see {@link #getBaseIndex()}) built on the model will be disposed alongside the engine, unless
+     * the user has manually added listeners on the base index that were not removed yet.
+     * <p>
+     * Disallowed if the engine is managed (see {@link #isManaged()}), as there may be other clients using it.
+     * <p>
+     * If you explicitly share a private, unmanaged engine between multiple sites, register a callback using
+     * {@link #addLifecycleListener(ViatraQueryEngineLifecycleListener)} to learn when another client has called this
+     * destructive method.
+     * 
+     * @throws UnsupportedOperationException
+     *             if engine is managed
+     */
+    public abstract void dispose();
+ 
+    /**
+     * Provides access to the selected query backend component of the VIATRA Query engine.
+     * @noreference for internal use only
+     * @throws ViatraQueryRuntimeException
+     */
+    public abstract IQueryBackend getQueryBackend(IQueryBackendFactory iQueryBackendFactory);
+    /**
+     * Access an existing pattern matcher based on a {@link IQuerySpecification}, and optional hints override.
+     * @param querySpecification a {@link IQuerySpecification} that describes a VIATRA query specification
+     * @param optionalOverrideHints a {@link QueryEvaluationHint} that may override the pattern hints (can be null)
+     * @return a pattern matcher corresponding to the specification, <code>null</code> if a matcher does not exist yet.
+     * @since 1.4
+     */
+    public abstract <Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> Matcher getExistingMatcher(IQuerySpecification<Matcher> querySpecification, QueryEvaluationHint optionalOverrideHints);
+    
+    /**
+     * Returns the immutable {@link ViatraQueryEngineOptions} of the engine.
+     * 
+     * @return the engine options
+     * @since 1.4
+     */
+    public abstract ViatraQueryEngineOptions getEngineOptions();
+    
+    /**
+     * Return the underlying result provider for the given matcher.
+     * 
+     * @beta This method may change in future versions
+     * @since 1.4
+     * @noreference This method is considered internal API
+     */
+    public abstract IQueryResultProvider getResultProviderOfMatcher(ViatraQueryMatcher<? extends IPatternMatch> matcher);
+    
+    /**
+     * The given callable will be executed, and all update propagation in stateful query backends 
+     * will be delayed until the execution is done. Within the callback, these backends will provide stale results.
+     * 
+     * <p> It is optional for a {@link IQueryBackend} to support the delaying of update propagation; stateless backends will display up-to-date results. 
+     * In this case, the given callable shall be executed, and the update propagation shall happen just like in non-delayed execution. 
+     * 
+     * <p> Example: in the Rete network, no messages will be propagated until the given callable is executed. 
+     * After the execution of the callable, all accumulated messages will be delivered. 
+     * 
+     * <p> The purpose of this method is that stateful query backends may save work when multiple model modifications are performed within the callback that partially cancel each other out.
+     * 
+     * @param callable the callable to be executed
+     * @return the result of the callable
+     * @since 1.6
+     */
+    public abstract <V> V delayUpdatePropagation(Callable<V> callable) throws InvocationTargetException;
+    
+    /**
+     * Returns true if the update propagation in this engine is currently delayed, false otherwise. 
+     * 
+     * @see {@link #delayUpdatePropagation(Callable)}
+     * @since 1.6
+     */
+    public abstract boolean isUpdatePropagationDelayed();
+    /**
+     * Returns true if the {@link #dispose()} method was called on this engine previously.
+     * @since 2.0
+     */
+    public abstract boolean isDisposed();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericPatternMatch.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericPatternMatch.java
new file mode 100644
index 00000000..b4de2b70
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericPatternMatch.java
@@ -0,0 +1,166 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import java.util.Arrays;
+import tools.refinery.viatra.runtime.api.impl.BasePatternMatch;
+/**
+ * Generic signature object implementation. 
+ *
+ * See also the generated matcher and signature of the pattern, with pattern-specific API simplifications.
+ *
+ * @author Bergmann Gábor
+ * @since 0.9
+ *
+ */
+public abstract class GenericPatternMatch extends BasePatternMatch {
+    private final GenericQuerySpecification<? extends GenericPatternMatcher> specification;
+    private final Object[] array;
+    private GenericPatternMatch(GenericQuerySpecification<? extends GenericPatternMatcher> specification, Object[] array) {
+        super();
+        this.specification = specification;
+        this.array = array;
+    }
+    @Override
+    public Object get(String parameterName) {
+        Integer index = specification.getPositionOfParameter(parameterName);
+        return index == null ? null : array[index];
+    }
+    @Override
+    public Object get(int position) {
+        return array[position];
+    }
+    @Override
+    public boolean set(String parameterName, Object newValue) {
+        if (!isMutable()) throw new UnsupportedOperationException();
+        Integer index = specification.getPositionOfParameter(parameterName);
+        if (index == null)
+            return false;
+        array[index] = newValue;
+        return true;
+    }
+    @Override
+    public Object[] toArray() {
+        return Arrays.copyOf(array, array.length);
+    }
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        for (int i = 0; i < array.length; ++i)
+            result = prime * result + ((array[i] == null) ? 0 : array[i].hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (!(obj instanceof GenericPatternMatch)) { // this should be infrequent
+            if (obj == null)
+                return false;
+            if (!(obj instanceof IPatternMatch))
+                return false;
+            IPatternMatch other = (IPatternMatch) obj;
+            if (!specification().equals(other.specification()))
+                return false;
+            return Arrays.deepEquals(array, other.toArray());
+        }
+        final GenericPatternMatch other = (GenericPatternMatch) obj;
+        return specification().equals(other.specification()) && Arrays.deepEquals(array, other.array);
+    }
+    @Override
+    public String prettyPrint() {
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < array.length; ++i) {
+            if (i != 0)
+                result.append(", ");
+            result.append("\"" + parameterNames().get(i) + "\"=" + prettyPrintValue(array[i]));
+        }
+        return result.toString();
+    }
+    @Override
+    public GenericQuerySpecification<? extends GenericPatternMatcher> specification() {
+        return specification;
+    }
+    
+    /**
+     * Returns an empty, mutable match. 
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input. 
+     * 
+     * @return the empty match
+     */
+    public static GenericPatternMatch newEmptyMatch(GenericQuerySpecification<? extends GenericPatternMatcher> specification) {
+        return new Mutable(specification, new Object[specification.getParameters().size()]);
+    }
+    /**
+     * Returns a mutable (partial) match. 
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input. 
+     * 
+     * @param parameters
+     *            the fixed value of pattern parameters, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     */
+    public static GenericPatternMatch newMutableMatch(GenericQuerySpecification<? extends GenericPatternMatcher> specification, Object... parameters) {
+        return new Mutable(specification, parameters);
+    }
+    /**
+     * Returns a new (partial) match. 
+     * This can be used e.g. to call the matcher with a partial match. 
+     * 
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch(GenericQuerySpecification)} to obtain a mutable match object.
+     * 
+     * @param parameters
+     *            the fixed value of pattern parameters, or null if not bound.
+     * @return the (partial) match object.
+     */
+    public static GenericPatternMatch newMatch(GenericQuerySpecification<? extends GenericPatternMatcher> specification, Object... parameters) {
+        return new Immutable(specification, Arrays.copyOf(parameters, parameters.length));
+    }
+    
+    @Override
+    public IPatternMatch toImmutable() {
+        return isMutable() ? newMatch(specification, array) : this;
+    }
+    static final class Mutable extends GenericPatternMatch {
+        Mutable(GenericQuerySpecification<? extends GenericPatternMatcher> specification, Object[] array) {
+            super(specification, array);
+        }
+        @Override
+        public boolean isMutable() {
+            return true;
+        }
+    }
+    static final class Immutable extends GenericPatternMatch {
+        Immutable(GenericQuerySpecification<? extends GenericPatternMatcher> specification, Object[] array) {
+            super(specification, array);
+        }
+        @Override
+        public boolean isMutable() {
+            return false;
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericPatternMatcher.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericPatternMatcher.java
new file mode 100644
index 00000000..9a3fbb44
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericPatternMatcher.java
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import tools.refinery.viatra.runtime.api.impl.BaseMatcher;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+/**
+ * This is a generic pattern matcher for any VIATRA pattern, with "interpretative" query execution.
+ * To use the pattern matcher on a given model, obtain a {@link GenericQuerySpecification} first, then 
+ * invoke e.g. {@link GenericQuerySpecification#getMatcher(ViatraQueryEngine)}.
+ * in conjunction with {@link ViatraQueryEngine#on(tools.refinery.viatra.runtime.api.scope.QueryScope)}.
+ * <p>
+ * Whenever available, consider using the pattern-specific generated matcher API instead.
+ * 
+ * <p>
+ * Matches of the pattern will be represented as {@link GenericPatternMatch}.
+ * 
+ * @author Bergmann Gábor
+ * @see GenericPatternMatch
+ * @see GenericMatchProcessor
+ * @see GenericQuerySpecification
+ * @since 0.9
+ */
+public class GenericPatternMatcher extends BaseMatcher<GenericPatternMatch> {
+    
+    /**
+     * @since 1.4
+     */
+    public GenericPatternMatcher(GenericQuerySpecification<? extends GenericPatternMatcher> specification) {
+        super(specification);
+    }
+    @Override
+    public GenericPatternMatch arrayToMatch(Object[] parameters) {
+        return GenericPatternMatch.newMatch(getSpecification(), parameters);
+    }
+    
+    @Override
+    public GenericPatternMatch arrayToMatchMutable(Object[] parameters) {
+        return GenericPatternMatch.newMutableMatch(getSpecification(), parameters);
+    }
+    @Override
+    protected GenericPatternMatch tupleToMatch(Tuple t) {
+        return new GenericPatternMatch.Immutable(getSpecification(), /*avoid re-cloning*/t.getElements());
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public GenericQuerySpecification<? extends GenericPatternMatcher> getSpecification() {
+        return (GenericQuerySpecification<? extends GenericPatternMatcher>)querySpecification;
+    }
+    /**
+     * Internal method for {@link GenericQuerySpecification}
+     * @noreference
+     */
+    static <Matcher extends GenericPatternMatcher> GenericPatternMatcher instantiate(GenericQuerySpecification<Matcher> querySpecification) {
+        return new GenericPatternMatcher(querySpecification);
+    }
+  
+    /**
+     * Internal method for {@link GenericQuerySpecification}
+     * @noreference
+     */
+    static <Matcher extends GenericPatternMatcher> GenericPatternMatcher instantiate(ViatraQueryEngine engine, GenericQuerySpecification<Matcher> querySpecification) {
+        // check if matcher already exists
+        GenericPatternMatcher matcher = engine.getExistingMatcher(querySpecification);
+        if (matcher == null) {
+            matcher = engine.getMatcher(querySpecification);
+        }       
+        return matcher;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericQueryGroup.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericQueryGroup.java
new file mode 100644
index 00000000..a5661bc9
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericQueryGroup.java
@@ -0,0 +1,82 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Mark Czotter, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import tools.refinery.viatra.runtime.api.impl.BaseQueryGroup;
+/**
+ * Generic implementation of {@link IQueryGroup}, covering an arbitrarily chosen set of patterns. Use the public
+ * constructor or static GenericQueryGroup.of(...) methods to instantiate.
+ * 
+ * @author Mark Czotter
+ * 
+ */
+public class GenericQueryGroup extends BaseQueryGroup {
+    private final Set<IQuerySpecification<?>> patterns;
+    /**
+     * Creates a GenericQueryGroup object with a set of patterns.
+     * 
+     * @param patterns
+     */
+    public GenericQueryGroup(Set<IQuerySpecification<?>> patterns) {
+        this.patterns = patterns;
+    }
+    @Override
+    public Set<IQuerySpecification<?>> getSpecifications() {
+        return patterns;
+    }
+    /**
+     * Creates a generic {@link IQueryGroup} instance from {@link IQuerySpecification} objects.
+     * 
+     * @since 2.0
+     */
+    public static IQueryGroup of(Stream<IQuerySpecification<?>> querySpecifications) {
+        return new GenericQueryGroup(querySpecifications.collect(Collectors.toSet()));
+    }
+    
+    /**
+     * Creates a generic {@link IQueryGroup} instance from {@link IQuerySpecification} objects.
+     * 
+     * @param querySpecifications
+     */
+    public static IQueryGroup of(Set<IQuerySpecification<?>> querySpecifications) {
+        return new GenericQueryGroup(querySpecifications);
+    }
+    /**
+     * Creates a generic {@link IQueryGroup} instance from {@link IQuerySpecification} objects.
+     * 
+     * @param querySpecifications
+     */
+    public static IQueryGroup of(IQuerySpecification<?>... querySpecifications) {
+        return of(new HashSet<IQuerySpecification<?>>(Arrays.asList(querySpecifications)));
+    }
+    /**
+     * Creates a generic {@link IQueryGroup} instance from other {@link IQueryGroup} objects (subgroups).
+     * 
+     */
+    public static IQueryGroup of(IQueryGroup... subGroups) {
+        Set<IQuerySpecification<?>> patterns = new HashSet<IQuerySpecification<?>>();
+        for (IQueryGroup group : subGroups) {
+            patterns.addAll(group.getSpecifications());
+        }
+        return new GenericQueryGroup(patterns);
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericQuerySpecification.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericQuerySpecification.java
new file mode 100644
index 00000000..5681ac19
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/GenericQuerySpecification.java
@@ -0,0 +1,76 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import tools.refinery.viatra.runtime.api.impl.BaseQuerySpecification;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PVisibility;
+/**
+ * This is a generic query specification for VIATRA pattern matchers, for "interpretative" query execution. 
+ * Should be subclassed by query specification implementations specific to query languages.
+ *
+ * <p>
+ * When available, consider using the pattern-specific generated matcher API instead.
+ *
+ * <p>
+ * The created matcher will be of type {@link GenericPatternMatcher}. Matches of the pattern will be represented as
+ * {@link GenericPatternMatch}.
+ * 
+ * <p>
+ * Note for overriding (if you have your own query language or ): 
+ * Derived classes should use {@link #defaultInstantiate(ViatraQueryEngine)} for implementing 
+ * {@link #instantiate(ViatraQueryEngine)} if they use {@link GenericPatternMatcher} proper.
+ *
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * @see GenericMatchProcessor
+ * @author Bergmann Gábor
+ * @noinstantiate This class is not intended to be instantiated by end-users.
+ * @since 0.9
+ */
+public abstract class GenericQuerySpecification<Matcher extends GenericPatternMatcher> extends
+        BaseQuerySpecification<Matcher> {
+    /**
+     * Instantiates query specification for the given internal query representation.
+     */
+    public GenericQuerySpecification(PQuery wrappedPQuery) {
+        super(wrappedPQuery);
+    }
+    @Override
+    public GenericPatternMatch newEmptyMatch() {
+        return GenericPatternMatch.newEmptyMatch(this);
+    }
+    @Override
+    public GenericPatternMatch newMatch(Object... parameters) {
+        return GenericPatternMatch.newMatch(this, parameters);
+    }
+    /**
+     * Derived classes should use this implementation of {@link #instantiate(ViatraQueryEngine)} 
+     * if they use {@link GenericPatternMatcher} proper.
+     * @throws ViatraQueryRuntimeException
+     */
+    protected GenericPatternMatcher defaultInstantiate(ViatraQueryEngine engine) {
+        return GenericPatternMatcher.instantiate(engine, this);
+    }
+    /**
+     * @since 2.0
+     */
+    @Override
+    public PVisibility getVisibility() {
+        return getInternalQueryRepresentation().getVisibility();
+    }
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IMatchUpdateListener.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IMatchUpdateListener.java
new file mode 100644
index 00000000..23c64537
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IMatchUpdateListener.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+/**
+ * An interface for low-level notifications about match appearance and disappearance.
+ * 
+ * <p>
+ * See {@link ViatraQueryMatcher#addCallbackOnMatchUpdate(IMatchUpdateListener, boolean)} for usage. Clients should
+ * consider using {@link MatchUpdateAdapter} or deriving their implementation from it.
+ * 
+ * @author Bergmann Gabor
+ * 
+ */
+public interface IMatchUpdateListener<Match extends IPatternMatch> {
+    /**
+     * Will be invoked on each new match that appears.
+     * 
+     * @param match
+     *            the match that has just appeared.
+     */
+    public void notifyAppearance(Match match);
+    /**
+     * Will be invoked on each existing match that disappears.
+     * 
+     * @param match
+     *            the match that has just disappeared.
+     */
+    public void notifyDisappearance(Match match);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IModelConnectorTypeEnum.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IModelConnectorTypeEnum.java
new file mode 100644
index 00000000..e672a6e2
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IModelConnectorTypeEnum.java
@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Andras Okros, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+/**
+ * This enum represents the possible notifier types which a model input should provide for the ui.
+ */
+public enum IModelConnectorTypeEnum {
+    RESOURCESET, RESOURCE;
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IPatternMatch.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IPatternMatch.java
new file mode 100644
index 00000000..be6467cc
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IPatternMatch.java
@@ -0,0 +1,107 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import java.util.List;
+/**
+ * Generic interface for a single match of a pattern. Each instance is a (partial) substitution of pattern parameters,
+ * essentially a parameter to value mapping.
+ * 
+ * <p>Can also represent a partial match; unsubstituted parameters are assigned to null. Pattern matchers must never return
+ * a partial match, but they accept partial matches as method parameters.
+ * 
+ * @author Bergmann Gábor
+ */
+public interface IPatternMatch extends Cloneable /* , Map<String, Object> */{
+    /** @return the pattern for which this is a match. */
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> specification();
+    /** Identifies the name of the pattern for which this is a match. */
+    public String patternName();
+    /** Returns the list of symbolic parameter names. */
+    public List<String> parameterNames();
+    /** Returns the value of the parameter with the given name, or null if name is invalid. */
+    public Object get(String parameterName);
+    /** Returns the value of the parameter at the given position, or null if position is invalid. */
+    public Object get(int position);
+    /**
+     * Sets the parameter with the given name to the given value.
+     * 
+     * <p> Works only if match is mutable. See {@link #isMutable()}.
+     * 
+     * @returns true if successful, false if parameter name is invalid. May also fail and return false if the value type
+     *          is incompatible.
+     * @throws UnsupportedOperationException if match is not mutable.
+     */
+    public boolean set(String parameterName, Object newValue);
+    /**
+     * Sets the parameter at the given position to the given value.
+     * 
+     * <p> Works only if match is mutable. See {@link #isMutable()}.
+     * 
+     * @returns true if successful, false if position is invalid. May also fail and return false if the value type is
+     *          incompatible.
+     * @throws UnsupportedOperationException if match is not mutable.
+     */
+    public boolean set(int position, Object newValue);
+    /**
+     * Returns whether the match object can be further modified after its creation. Setters work only if the match is mutable. 
+     * 
+     * <p>Matches computed by the pattern matchers are not mutable, so that the match set cannot be modified externally. 
+     * Partial matches used as matcher input, however, can be mutable; such match objects can be created using {@link ViatraQueryMatcher#newEmptyMatch()}. 
+     * 
+     * @return whether the match can be modified
+     */
+    public boolean isMutable();
+    
+    /** 
+     * Converts the match to an array representation, with each pattern parameter at their respective position. 
+     * In case of a partial match, unsubstituted parameters will be represented as null elements in the array. 
+     *
+     * @return a newly constructed array containing each parameter substitution of the match in order.
+     */
+    public Object[] toArray();
+    
+    /**
+     * Takes an immutable snapshot of this match.
+     * @return the match itself in case of immutable matches, an immutable copy in case of mutable ones.
+     */
+    public IPatternMatch toImmutable();
+    
+    /** Prints the list of parameter-value pairs. */
+    public String prettyPrint();
+    
+    /**
+     * Checks that this match is compatible with the given other match.
+     * This is used for filtering the match set of a matcher.
+     * 
+     * <p/> Two non-null matches are compatible if and only if:
+     * <ul>
+     *   <li>They share the same pattern.</li>
+     *   <li>For each parameter, where they are set (non-null) in both matches,
+     *    their values are equal.</li>
+     *   </li>  
+     * </ul>
+     * 
+     * <p/> Furthermore, all matches are considered compatible with
+     *  null matches (e.g. empty filter).
+     * 
+     * @param other
+     * @return true, if this is compatible with other, or other is null
+     */
+    public boolean isCompatibleWith(IPatternMatch other);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IQueryGroup.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IQueryGroup.java
new file mode 100644
index 00000000..a783f823
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IQueryGroup.java
@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Mark Czotter, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import java.util.Set;
+/**
+ * Generic interface for group of query specifications.
+ * 
+ * <p>It handles more than one patterns as a group, and provides functionality to initialize the matchers together (which
+ * has performance benefits).
+ * 
+ * @author Mark Czotter
+ * 
+ */
+public interface IQueryGroup {
+    /**
+     * Initializes matchers for the group of patterns within an {@link ViatraQueryEngine}. If some of the pattern matchers are already
+     * constructed in the engine, no task is performed for them.
+     * 
+     * <p>
+     * This preparation step has the advantage that it prepares pattern matchers for an arbitrary number of patterns in a
+     * single-pass traversal of the model. 
+     * This is typically more efficient than traversing the model each time an individual pattern matcher is initialized on demand. 
+     * The performance benefit only manifests itself if the engine is not in wildcard mode.
+     * 
+     * @param engine
+     *            the existing VIATRA Query engine in which the matchers will be created.
+     * @throws ViatraQueryRuntimeException
+     *             if there was an error in preparing the engine
+     */
+    public void prepare(ViatraQueryEngine engine);
+    /**
+     * Returns the currently assigned {@link IQuerySpecification}s.
+     */
+    public Set<IQuerySpecification<?>> getSpecifications();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IQuerySpecification.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IQuerySpecification.java
new file mode 100644
index 00000000..9b84b031
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IQuerySpecification.java
@@ -0,0 +1,87 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import tools.refinery.viatra.runtime.api.scope.QueryScope;
+import tools.refinery.viatra.runtime.emf.EMFScope;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQueryHeader;
+/**
+ * API interface for a VIATRA query specification. Each query is associated with a pattern. Methods instantiate a matcher
+ * of the pattern with various parameters.
+ * 
+ * <p> As of 0.9.0, some internal details (mostly relevant for query evaluator backends) have been moved to {@link #getInternalQueryRepresentation()}.  
+ *
+ * @author Bergmann Gábor
+ *
+ */
+public interface IQuerySpecification<Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> extends PQueryHeader {
+    /**
+     * Initializes the pattern matcher within an existing {@link ViatraQueryEngine}. If the pattern matcher is already
+     * constructed in the engine, only a lightweight reference is created.
+     * <p>
+     * The match set will be incrementally refreshed upon updates.
+     *
+     * @param engine
+     *            the existing VIATRA Query engine in which this matcher will be created.
+     * @throws ViatraQueryRuntimeException
+     *             if an error occurs during pattern matcher creation
+     */
+    public Matcher getMatcher(ViatraQueryEngine engine);
+    
+    /**
+     * Returns an empty, mutable Match compatible with matchers of this query. 
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input. 
+     * This can be used to call the matcher with a partial match 
+     *  even if the specific class of the matcher or the match is unknown.
+     * 
+     * @return the empty match
+     */
+    public abstract IPatternMatch newEmptyMatch();
+    /**
+     * Returns a new (partial) Match object compatible with matchers of this query. 
+     * This can be used e.g. to call the matcher with a partial
+     * match. 
+     * 
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * 
+     * @param parameters
+     *            the fixed value of pattern parameters, or null if not bound.
+     * @return the (partial) match object.
+     */
+    public abstract IPatternMatch newMatch(Object... parameters);
+    
+    /**
+     * The query is formulated over this kind of modeling platform.
+     * E.g. for queries over EMF models, the {@link EMFScope} class is returned.
+     */
+    public Class<? extends QueryScope> getPreferredScopeClass();
+    
+    /**
+     * Returns the definition of the query in a format intended for consumption by the query evaluator. 
+     * @return the internal representation of the query.
+     */
+    public PQuery getInternalQueryRepresentation();
+    
+    /**
+     * Creates a new uninitialized matcher, which is not functional until an engine initializes it. Clients
+     * should not call this method, it is used by the {@link ViatraQueryEngine} instance to instantiate matchers.
+     * @throws ViatraQueryRuntimeException 
+     * @noreference This method is not intended to be referenced by clients.
+     * @since 1.4
+     */
+    public Matcher instantiate();
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IRunOnceQueryEngine.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IRunOnceQueryEngine.java
new file mode 100644
index 00000000..b625980b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/IRunOnceQueryEngine.java
@@ -0,0 +1,68 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import java.util.Collection;
+import org.eclipse.emf.common.notify.Notifier;
+import tools.refinery.viatra.runtime.base.api.BaseIndexOptions;
+import tools.refinery.viatra.runtime.base.api.NavigationHelper;
+/**
+ * A run-once query engine is used to get matches for queries without incremental support.
+ * Users can create a query engine with a given {@link Notifier} as scope and use a query specification
+ * to retrieve the current match set with this scope (see {@link #getAllMatches}).
+ * 
+ * @author Abel Hegedus
+ * 
+ */
+public interface IRunOnceQueryEngine {
+    /**
+     * Returns the set of all matches for the given query in the scope of the engine.
+     * 
+     * @param querySpecification the query that is evaluated
+     * @return matches represented as a Match object.
+     */
+    <Match extends IPatternMatch> Collection<Match> getAllMatches(
+            final IQuerySpecification<? extends ViatraQueryMatcher<Match>> querySpecification);
+    /**
+     * @return the scope of pattern matching, i.e. the root of the EMF model tree that this engine is attached to.
+     */
+    Notifier getScope();
+    
+    /**
+     * The base index options specifies how the base index is built, including wildcard mode (defaults to false) and
+     * dynamic EMF mode (defaults to false). See {@link NavigationHelper} for the explanation of wildcard mode and
+     * dynamic EMF mode.
+     * 
+     * <p/> The returned options can be modified in order to affect subsequent calls of {@link #getAllMatches}.
+     * 
+     * @return the base index options used by the engine. 
+     */
+    BaseIndexOptions getBaseIndexOptions(); 
+    
+    /**
+     * When set to true, the run-once query engine will not dispose it's engine and will resample the values of derived
+     * features before returning matches if the model changed since the last call.
+     * 
+     * If the values of derived features may change without any model modification, call {@link #resampleOnNextCall()}
+     * before subsequent calls of {@link #getAllMatches}.
+     * 
+     * @param automaticResampling
+     */
+    void setAutomaticResampling(boolean automaticResampling);
+    
+    /**
+     * If automatic resampling is enabled and the value of derived features may change without model modifications,
+     * calling this method will make sure that re-sampling will occur before returning match results.
+     */
+    void resampleOnNextCall();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/LazyLoadingQueryGroup.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/LazyLoadingQueryGroup.java
new file mode 100644
index 00000000..6ae44b7c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/LazyLoadingQueryGroup.java
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import java.util.Collections;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.api.impl.BaseQueryGroup;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+import tools.refinery.viatra.runtime.util.ViatraQueryLoggingUtil;
+/**
+ * Initializes a query group from a set of query providers. The query providers are not executed until the queries
+ * themselves are asked in the {@link #getSpecifications()} method.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.3
+ *
+ */
+public class LazyLoadingQueryGroup extends BaseQueryGroup {
+    private final Set<? extends Supplier<IQuerySpecification<?>>> providers;
+    private Set<IQuerySpecification<?>> specifications = null;
+    /**
+     * @param providers a non-null set to initialize the group
+     */
+    public LazyLoadingQueryGroup(Set<? extends Supplier<IQuerySpecification<?>>> providers) {
+        Preconditions.checkArgument(providers != null, "The set of providers must not be null");
+        this.providers = providers;
+    }
+    /**
+     * @param providers a non-null set to initialize the group
+     */
+    public static IQueryGroup of(Set<? extends Supplier<IQuerySpecification<?>>> querySpecifications) {
+        return new LazyLoadingQueryGroup(querySpecifications);
+    }
+    @Override
+    public Set<IQuerySpecification<?>> getSpecifications() {
+        if (specifications == null) {
+            try {
+                specifications = providers.stream().filter(Objects::nonNull).map(Supplier::get).filter(Objects::nonNull).collect(Collectors.toSet());
+            } catch (Exception e) {
+                // TODO maybe store in issue list and provide better error reporting in general
+                String errorMessage = "Exception occurred while accessing query specification from provider: " + e.getMessage();
+                ViatraQueryLoggingUtil.getLogger(getClass()).error(errorMessage);
+                return Collections.emptySet();
+            }
+        }
+        return specifications;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/MatchUpdateAdapter.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/MatchUpdateAdapter.java
new file mode 100644
index 00000000..7de6d2c6
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/MatchUpdateAdapter.java
@@ -0,0 +1,105 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import java.util.function.Consumer;
+/**
+ * A default implementation of {@link IMatchUpdateListener} that contains two match processors, one for appearance, one
+ * for disappearance. Any of the two can be null; in this case, corresponding notifications will be ignored.
+ * 
+ * <p>
+ * Instantiate using either constructor.
+ * 
+ * @author Bergmann Gabor
+ * 
+ */
+public class MatchUpdateAdapter<Match extends IPatternMatch> implements IMatchUpdateListener<Match> {
+    Consumer<Match> appearCallback;
+    Consumer<Match> disappearCallback;
+    /**
+     * Constructs an instance without any match processors registered yet.
+     * 
+     * Use {@link #setAppearCallback(Consumer)} and {@link #setDisappearCallback(Consumer)} to specify
+     * optional match processors for match appearance and disappearance, respectively.
+     */
+    public MatchUpdateAdapter() {
+        super();
+    }
+    /**
+     * Constructs an instance by specifying match processors.
+     * 
+     * @param appearCallback
+     *            a match processor that will be invoked on each new match that appears. If null, no callback will be
+     *            executed on match appearance. See {@link Consumer} for details on how to implement.
+     * @param disappearCallback
+     *            a match processor that will be invoked on each existing match that disappears. If null, no callback
+     *            will be executed on match disappearance. See {@link Consumer} for details on how to implement.
+     * @since 2.0
+     */
+    public MatchUpdateAdapter(Consumer<Match> appearCallback, Consumer<Match> disappearCallback) {
+        super();
+        setAppearCallback(appearCallback);
+        setDisappearCallback(disappearCallback);
+    }
+    /**
+     * @return the match processor that will be invoked on each new match that appears. If null, no callback will be
+     *         executed on match appearance.
+     * @since 2.0
+     */
+    public Consumer<Match> getAppearCallback() {
+        return appearCallback;
+    }
+    /**
+     * @param appearCallback
+     *            a match processor that will be invoked on each new match that appears. If null, no callback will be
+     *            executed on match appearance. See {@link Consumer} for details on how to implement.
+     * @since 2.0
+     */
+    public void setAppearCallback(Consumer<Match> appearCallback) {
+        this.appearCallback = appearCallback;
+    }
+    /**
+     * @return the match processor that will be invoked on each existing match that disappears. If null, no callback
+     *         will be executed on match disappearance.
+     * @since 2.0
+     */
+    public Consumer<Match> getDisappearCallback() {
+        return disappearCallback;
+    }
+    /**
+     * @param disappearCallback
+     *            a match processor that will be invoked on each existing match that disappears. If null, no callback
+     *            will be executed on match disappearance. See {@link Consumer} for details on how to implement.
+     * @since 2.0
+     */
+    public void setDisappearCallback(Consumer<Match> disappearCallback) {
+        this.disappearCallback = disappearCallback;
+    }
+    @Override
+    public void notifyAppearance(Match match) {
+        if (appearCallback != null)
+            appearCallback.accept(match);
+    }
+    @Override
+    public void notifyDisappearance(Match match) {
+        if (disappearCallback != null)
+            disappearCallback.accept(match);
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/PackageBasedQueryGroup.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/PackageBasedQueryGroup.java
new file mode 100644
index 00000000..252bb7fd
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/PackageBasedQueryGroup.java
@@ -0,0 +1,133 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Abel Hegedus, Mark Czotter, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import tools.refinery.viatra.runtime.api.impl.BaseQueryGroup;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistry;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistryEntry;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistryChangeListener;
+import tools.refinery.viatra.runtime.registry.IRegistryView;
+import tools.refinery.viatra.runtime.registry.IRegistryViewFilter;
+import tools.refinery.viatra.runtime.registry.QuerySpecificationRegistry;
+/**
+ * Package based {@link BaseQueryGroup} implementation. It handles patterns as a group within the same package.
+ * 
+ * @author Abel Hegedus, Mark Czotter
+ * 
+ */
+public class PackageBasedQueryGroup extends BaseQueryGroup {
+    private final Set<IQuerySpecification<?>> querySpecifications = new HashSet<>();
+    private final String packageName;
+    private final boolean includeSubPackages;
+    private IRegistryView view;
+    /**
+     * Creates a query group with specifications of a given package from the {@link QuerySpecificationRegistry}. Only
+     * query specifications with the exact package fully qualified name are included.
+     * 
+     * @param packageName
+     *            that contains the specifications
+     */
+    public PackageBasedQueryGroup(String packageName) {
+        this(packageName, false);
+    }
+    /**
+     * Creates a query group with specifications of a given package from the {@link QuerySpecificationRegistry}.
+     * 
+     * @param packageName
+     *            that contain the specifications
+     * @param includeSubPackages
+     *            if true all query specifications with package names starting with the given package are included
+     */
+    public PackageBasedQueryGroup(String packageName, boolean includeSubPackages) {
+        super();
+        this.packageName = packageName;
+        this.includeSubPackages = includeSubPackages;
+        IQuerySpecificationRegistry registry = QuerySpecificationRegistry.getInstance();
+        view = registry.createView(new PackageNameBasedViewFilter());
+        for (IQuerySpecificationRegistryEntry entry : view.getEntries()) {
+            this.querySpecifications.add(entry.get());
+        }
+        SpecificationSetUpdater listener = new SpecificationSetUpdater();
+        view.addViewListener(listener);
+    }
+    @Override
+    public Set<IQuerySpecification<?>> getSpecifications() {
+        return Collections.unmodifiableSet(new HashSet<>(querySpecifications));
+    }
+    public String getPackageName() {
+        return packageName;
+    }
+    public boolean isIncludeSubPackages() {
+        return includeSubPackages;
+    }
+    /**
+     * Refreshes the pattern group from the query specification registry based on the parameters used during the
+     * initialization.
+     */
+    public void refresh() {
+        // do nothing, view is automatically refreshed
+    }
+    /**
+     * Listener to update the specification set
+     * 
+     * @author Abel Hegedus
+     *
+     */
+    private final class SpecificationSetUpdater implements IQuerySpecificationRegistryChangeListener {
+        @Override
+        public void entryAdded(IQuerySpecificationRegistryEntry entry) {
+            querySpecifications.add(entry.get());
+        }
+    
+        @Override
+        public void entryRemoved(IQuerySpecificationRegistryEntry entry) {
+            querySpecifications.remove(entry.get());
+        }
+    }
+    /**
+     * Registry view filter that checks FQNs against the given package name.
+     * 
+     * @author Abel Hegedus
+     *
+     */
+    private final class PackageNameBasedViewFilter implements IRegistryViewFilter {
+        @Override
+        public boolean isEntryRelevant(IQuerySpecificationRegistryEntry entry) {
+            String fqn = entry.getFullyQualifiedName();
+            if (packageName.length() + 1 < fqn.length()) {
+                if (includeSubPackages) {
+                    if (fqn.startsWith(packageName + '.')) {
+                        return true;
+                    }
+                } else {
+                    String name = fqn.substring(fqn.lastIndexOf('.') + 1, fqn.length());
+                    if (fqn.equals(packageName + '.' + name)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngine.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngine.java
new file mode 100644
index 00000000..fd8ff848
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngine.java
@@ -0,0 +1,152 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import org.eclipse.emf.common.notify.Notifier;
+import tools.refinery.viatra.runtime.api.scope.IBaseIndex;
+import tools.refinery.viatra.runtime.api.scope.QueryScope;
+import tools.refinery.viatra.runtime.base.api.BaseIndexOptions;
+import tools.refinery.viatra.runtime.emf.EMFScope;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import java.util.Set;
+import java.util.stream.Collectors;
+/**
+ * A Viatra Query (incremental) evaluation engine, attached to a model such as an EMF resource. The engine hosts pattern matchers, and
+ * will listen on model update notifications stemming from the given model in order to maintain live results.
+ *
+ * <p>
+ * By default, ViatraQueryEngines do not need to be separately disposed; they will be garbage collected along with the model.
+ * Advanced users: see {@link AdvancedViatraQueryEngine} if you want fine control over the lifecycle of an engine.
+ *
+ * <p>
+ * Pattern matchers within this engine may be instantiated in the following ways:
+ * <ul>
+ * <li>Recommended: instantiate the specific matcher class generated for the pattern by e.g. MyPatternMatcher.on(engine).
+ * <li>Use {@link #getMatcher(IQuerySpecification)} if the pattern-specific generated matcher API is not available.
+ * <li>Advanced: use the query specification associated with the generated matcher class to achieve the same.
+ * </ul>
+ * Additionally, a group of patterns (see {@link IQueryGroup}) can be initialized together before usage; this may improve
+ * the performance of pattern matcher construction by trying to gather all necessary information from the model in one go.
+ * Note that no such improvement is to be expected if the engine is specifically constructed in wildcard mode,
+ * an option available in some scope implementations
+ * (see {@link EMFScope#EMFScope(Notifier, BaseIndexOptions)} and {@link BaseIndexOptions#withWildcardMode(boolean)}).
+ *
+ *
+ * @author Bergmann Gábor
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public abstract class ViatraQueryEngine {
+    /**
+     * Obtain a (managed) {@link ViatraQueryEngine} to evaluate queries over a given scope specified by an {@link QueryScope}.
+     *
+     * <p> For a given matcher scope, the same engine will be returned to any client.
+     * This facilitates the reuse of internal caches of the engine, greatly improving performance.
+     *
+     * <p> The lifecycle of this engine is centrally managed, and will not be disposed as long as the model is retained in memory.
+     * The engine will be garbage collected along with the model.
+     *
+     * <p>
+     * Advanced users: see {@link AdvancedViatraQueryEngine#createUnmanagedEngine(QueryScope)} to obtain a private,
+     * unmanaged engine that is not shared with other clients and allows tight control over its lifecycle.
+     *
+     * @param scope
+     *          the scope of query evaluation; the definition of the set of model elements that this engine is operates on.
+     *          Provide e.g. a {@link EMFScope} for evaluating queries on an EMF model.
+     * @return a (managed) {@link ViatraQueryEngine} instance
+     */
+    public static ViatraQueryEngine on(QueryScope scope) {
+        return ViatraQueryEngineManager.getInstance().getQueryEngine(scope);
+    }
+    /**
+     * Obtain a (managed) {@link ViatraQueryEngine} to evaluate queries over a given scope specified by an {@link QueryScope}.
+     *
+     * <p> For a given matcher scope, the same engine will be returned to any client.
+     * This facilitates the reuse of internal caches of the engine, greatly improving performance.
+     *
+     * <p> The lifecycle of this engine is centrally managed, and will not be disposed as long as the model is retained in memory.
+     * The engine will be garbage collected along with the model.
+     *
+     * <p>
+     * Advanced users: see {@link AdvancedViatraQueryEngine#createUnmanagedEngine(QueryScope)} to obtain a private,
+     * unmanaged engine that is not shared with other clients and allows tight control over its lifecycle.
+     *
+     * @param scope
+     *      the scope of query evaluation; the definition of the set of model elements that this engine is operates on.
+     *      Provide e.g. a {@link EMFScope} for evaluating queries on an EMF model.
+     * @return a (managed) {@link ViatraQueryEngine} instance
+     * @since 1.4
+     */
+    public static ViatraQueryEngine on(QueryScope scope, ViatraQueryEngineOptions options) {
+        return ViatraQueryEngineManager.getInstance().getQueryEngine(scope, options);
+    }
+    /**
+     * Provides access to the internal base index component of the engine, responsible for keeping track of basic
+     * contents of the model.
+     *
+     * <p>If using an {@link EMFScope},
+     *  consider {@link EMFScope#extractUnderlyingEMFIndex(ViatraQueryEngine)} instead to access EMF-specific details.
+     *
+     * @return the baseIndex the NavigationHelper maintaining the base index
+     * @throws ViatraQueryRuntimeException
+     *             if the base index could not be constructed
+     */
+    public abstract IBaseIndex getBaseIndex();
+    /**
+     * Access a pattern matcher based on a {@link IQuerySpecification}.
+     * Multiple calls will return the same matcher.
+     * @param querySpecification a {@link IQuerySpecification} that describes a VIATRA query specification
+     * @return a pattern matcher corresponding to the specification
+     * @throws ViatraQueryRuntimeException if the matcher could not be initialized
+     */
+    public abstract <Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> Matcher getMatcher(IQuerySpecification<Matcher> querySpecification);
+    /**
+     * Access a pattern matcher for the graph pattern with the given fully qualified name.
+     * Will succeed only if a query specification for this fully qualified name has been generated and registered.
+     * Multiple calls will return the same matcher unless the registered specification changes.
+     *
+     * @param patternFQN the fully qualified name of a VIATRA query specification
+     * @return a pattern matcher corresponding to the specification
+     * @throws ViatraQueryRuntimeException if the matcher could not be initialized
+     */
+    public abstract ViatraQueryMatcher<? extends IPatternMatch> getMatcher(String patternFQN);
+    /**
+     * Access an existing pattern matcher based on a {@link IQuerySpecification}.
+     * @param querySpecification a {@link IQuerySpecification} that describes a VIATRA query specification
+     * @return a pattern matcher corresponding to the specification, <code>null</code> if a matcher does not exist yet.
+     */
+    public abstract <Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> Matcher getExistingMatcher(IQuerySpecification<Matcher> querySpecification);
+    /**
+     * Access a copy of available {@link ViatraQueryMatcher} pattern matchers.
+     * @return a copy of the set of currently available pattern matchers registered on this engine instance
+     */
+    public abstract Set<? extends ViatraQueryMatcher<? extends IPatternMatch>> getCurrentMatchers();
+    public Set<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> getRegisteredQuerySpecifications() {
+        return getCurrentMatchers().stream().map(ViatraQueryMatcher::getSpecification).collect(Collectors.toSet());
+    }
+    /**
+     * @return the scope of query evaluation; the definition of the set of model elements that this engine is operates on.
+     */
+    public abstract QueryScope getScope();
+        public abstract void flushChanges();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineInitializationListener.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineInitializationListener.java
new file mode 100644
index 00000000..02162a65
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineInitializationListener.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+/**
+ * Listener interface to get notifications when a new managed engine is initialized.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public interface ViatraQueryEngineInitializationListener {
+    /**
+     * Called when a managed engine is initialized in the EngineManager.
+     * 
+     * @param engine the initialized engine
+     */
+    void engineInitialized(AdvancedViatraQueryEngine engine);
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineLifecycleListener.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineLifecycleListener.java
new file mode 100644
index 00000000..1c4dc264
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineLifecycleListener.java
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+/**
+ * Listener interface for getting notification on changes in an {@link ViatraQueryEngine}.
+ * 
+ * You can use it to remove any other listeners that you attached to matchers or the engine,
+ * or to handle matchers that are initialized after you started using the engine.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public interface ViatraQueryEngineLifecycleListener {
+    // -------------------------------------------------------------------------------
+    // MATCHERS (methods notifying on changes in the matchers available in the engine)
+    // -------------------------------------------------------------------------------
+    
+    /**
+     * Called after a matcher is instantiated in the engine
+     *  
+     * @param matcher the new matcher
+     */
+    void matcherInstantiated(ViatraQueryMatcher<? extends IPatternMatch> matcher);
+    
+    // -------------------------------------------------------------------------
+    // HEALTH (methods notifying on changes that affect the health of the engine
+    // -------------------------------------------------------------------------
+    
+    /**
+     * Called after the engine has become tainted due to a fatal error
+     */
+    void engineBecameTainted(String message, Throwable t);
+    
+    /**
+     * Called after the engine has been wiped
+     */
+    void engineWiped();
+    
+    /**
+     * Called after the engine has been disposed
+     */
+    void engineDisposed();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineManager.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineManager.java
new file mode 100644
index 00000000..ca709b02
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineManager.java
@@ -0,0 +1,196 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import static tools.refinery.viatra.runtime.matchers.util.Preconditions.checkArgument;
+import java.lang.ref.WeakReference;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+import tools.refinery.viatra.runtime.api.scope.QueryScope;
+import tools.refinery.viatra.runtime.emf.EMFScope;
+import tools.refinery.viatra.runtime.internal.apiimpl.ViatraQueryEngineImpl;
+import tools.refinery.viatra.runtime.util.ViatraQueryLoggingUtil;
+/**
+ * Global registry of active VIATRA Query Engines.
+ * 
+ * <p>
+ * Manages an {@link ViatraQueryEngine} for each model (more precisely scope), that is created on demand. Managed engines are shared between
+ * clients querying the same model.
+ * 
+ * <p>
+ * It is also possible to create private, unmanaged engines that are not shared between clients.
+ * 
+ * <p>
+ * Only weak references are retained on the managed engines. So if there are no other references to the matchers or the
+ * engine, they can eventually be GC'ed, and they won't block the model from being GC'ed either.
+ * 
+ * 
+ * @author Bergmann Gabor
+ * 
+ */
+public class ViatraQueryEngineManager {
+    private static ViatraQueryEngineManager instance = new ViatraQueryEngineManager();
+    
+    /**
+     * @return the singleton instance
+     */
+    public static ViatraQueryEngineManager getInstance() {
+        return instance;
+    }
+    /**
+     * The engine manager keeps track of the managed engines via weak references only, so it will not keep unused
+     * managed engines from being garbage collected. Still, as long as the user keeps the model in memory, the
+     * associated managed engine will not be garbage collected, as it is expected to be strongly reachable from the
+     * model via the scope-specific base index or change notification listeners (see
+     * {@link BaseIndexListener#iqEngine}).
+     */
+    Map<QueryScope, WeakReference<ViatraQueryEngineImpl>> engines;
+    ViatraQueryEngineManager() {
+        super();
+        engines = new WeakHashMap<QueryScope, WeakReference<ViatraQueryEngineImpl>>();
+        initializationListeners = new HashSet<ViatraQueryEngineInitializationListener>();
+    }
+    /**
+     * Creates a managed VIATRA Query Engine at a given scope (e.g. an EMF Resource or ResourceSet, as in {@link EMFScope}) 
+     * or retrieves an already existing one. Repeated invocations for a single model root will return the same engine. 
+     * Consequently, the engine will be reused between different clients querying the same model, providing performance benefits.
+     * 
+     * <p>
+     * The match set of any patterns will be incrementally refreshed upon updates from this scope.
+     * 
+     * @param scope 
+     *          the scope of query evaluation; the definition of the set of model elements that this engine is operates on. 
+     *          Provide e.g. a {@link EMFScope} for evaluating queries on an EMF model.
+     * @return a new or previously existing engine
+     */
+    public ViatraQueryEngine getQueryEngine(QueryScope scope) {
+        return getQueryEngine(scope, ViatraQueryEngineOptions.getDefault());
+    }
+    
+    /**
+     * Creates a managed VIATRA Query Engine at a given scope (e.g. an EMF Resource or ResourceSet, as in {@link EMFScope}) 
+     * or retrieves an already existing one. Repeated invocations for a single model root will return the same engine. 
+     * Consequently, the engine will be reused between different clients querying the same model, providing performance benefits.
+     * 
+     * <p>
+     * The match set of any patterns will be incrementally refreshed upon updates from this scope.
+     * 
+     * @param scope 
+     *      the scope of query evaluation; the definition of the set of model elements that this engine is operates on. 
+     *      Provide e.g. a {@link EMFScope} for evaluating queries on an EMF model.
+     * @return a new or previously existing engine
+     * @since 1.4
+     */
+    public ViatraQueryEngine getQueryEngine(QueryScope scope, ViatraQueryEngineOptions options) {
+        ViatraQueryEngineImpl engine = getEngineInternal(scope);
+        if (engine == null) {
+            engine = new ViatraQueryEngineImpl(this, scope, options);
+            engines.put(scope, new WeakReference<ViatraQueryEngineImpl>(engine));
+            notifyInitializationListeners(engine);
+        }
+        return engine;
+    }
+    /**
+     * Retrieves an already existing managed VIATRA Query Engine.
+     * 
+     * @param scope 
+     *          the scope of query evaluation; the definition of the set of model elements that this engine is operates on. 
+     *          Provide e.g. a {@link EMFScope} for evaluating queries on an EMF model.
+     * @return a previously existing engine, or null if no engine is active for the given EMF model root
+     */
+    public ViatraQueryEngine getQueryEngineIfExists(QueryScope scope) {
+        return getEngineInternal(scope);
+    }
+    /**
+     * Collects all {@link ViatraQueryEngine} instances that still exist.
+     * 
+     * @return set of engines if there is any, otherwise EMTPY_SET
+     */
+    public Set<ViatraQueryEngine> getExistingQueryEngines(){
+        Set<ViatraQueryEngine> existingEngines = null;
+        for (WeakReference<ViatraQueryEngineImpl> engineRef : engines.values()) {
+            AdvancedViatraQueryEngine engine = engineRef == null ? null : engineRef.get();
+            if(existingEngines == null) {
+                existingEngines = new HashSet<>();
+            }
+            existingEngines.add(engine);
+        }
+        if(existingEngines == null) {
+            existingEngines = Collections.emptySet();
+        }
+        return existingEngines;
+    }
+        
+    private final Set<ViatraQueryEngineInitializationListener> initializationListeners;
+    
+    /**
+     * Registers a listener for new engine initialization.
+     * 
+     * <p/> For removal, use {@link #removeQueryEngineInitializationListener}
+     * 
+     * @param listener the listener to register
+     */
+    public void addQueryEngineInitializationListener(ViatraQueryEngineInitializationListener listener) {
+        checkArgument(listener != null, "Cannot add null listener!");
+        initializationListeners.add(listener);
+    }
+    /**
+     * Removes a registered listener added with {@link #addQueryEngineInitializationListener}
+     * 
+     * @param listener
+     */
+    public void removeQueryEngineInitializationListener(ViatraQueryEngineInitializationListener listener) {
+        checkArgument(listener != null, "Cannot remove null listener!");
+        initializationListeners.remove(listener);
+    }
+    /**
+     * Notifies listeners that a new engine has been initialized.
+     * 
+     * @param engine the initialized engine
+     */
+    protected void notifyInitializationListeners(AdvancedViatraQueryEngine engine) {
+        try {
+            if (!initializationListeners.isEmpty()) {
+                for (ViatraQueryEngineInitializationListener listener : new HashSet<>(initializationListeners)) {
+                    listener.engineInitialized(engine);
+                }
+            }
+        } catch (Exception ex) {
+            ViatraQueryLoggingUtil.getLogger(getClass()).fatal(
+                    "VIATRA Query Engine Manager encountered an error in delivering notifications"
+                            + " about engine initialization. ", ex);
+        }
+    }
+    /**
+     * @param emfRoot
+     * @return
+     */
+    private ViatraQueryEngineImpl getEngineInternal(QueryScope scope) {
+        final WeakReference<ViatraQueryEngineImpl> engineRef = engines.get(scope);
+        ViatraQueryEngineImpl engine = engineRef == null ? null : engineRef.get();
+        return engine;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineOptions.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineOptions.java
new file mode 100644
index 00000000..15bf1f91
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngineOptions.java
@@ -0,0 +1,293 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Balázs Grill, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import java.util.Objects;
+import java.util.ServiceLoader;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendFactory;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendFactoryProvider;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+/**
+ * This class is intended to provide options to a created {@link ViatraQueryEngine} instance. The {@link #DEFAULT}
+ * instance represents the configuration that is selected when no explicit options are provided by the user. To create
+ * new configurations, use the static builder methods {@link #defineOptions()} (starts with empty options) or
+ * {@link #copyOptions(ViatraQueryEngineOptions)} (starts with all options from an existing configuration).
+ * 
+ * @author Balázs Grill, Zoltan Ujhelyi
+ * @since 1.4
+ *
+ */
+public final class ViatraQueryEngineOptions {
+    private static boolean areSystemDefaultsCalculated = false;
+    private static IQueryBackendFactory systemDefaultBackendFactory;
+    private static IQueryBackendFactory systemDefaultCachingBackendFactory;
+    private static IQueryBackendFactory systemDefaultSearchBackendFactory;
+    
+    /**
+     * @since 2.0
+     */
+    public static void setSystemDefaultBackends(IQueryBackendFactory systemDefaultBackendFactory,
+            IQueryBackendFactory systemDefaultCachingBackendFactory,
+            IQueryBackendFactory systemDefaultSearchBackendFactory) {
+                areSystemDefaultsCalculated = true;
+                ViatraQueryEngineOptions.systemDefaultBackendFactory = systemDefaultBackendFactory;
+                ViatraQueryEngineOptions.systemDefaultCachingBackendFactory = systemDefaultCachingBackendFactory;
+                ViatraQueryEngineOptions.systemDefaultSearchBackendFactory = systemDefaultSearchBackendFactory;
+    }
+    
+    /**
+     * If {@link #setSystemDefaultBackends(IQueryBackendFactory, IQueryBackendFactory, IQueryBackendFactory)} is not
+     * called, this method is responsible of finding the corresponding backends on the classpath using Java Service
+     * loaders.
+     */
+    private static void calculateSystemDefaultBackends() {
+        for (IQueryBackendFactoryProvider provider : ServiceLoader.load(IQueryBackendFactoryProvider.class)) {
+            if (provider.isSystemDefaultEngine()) {
+                systemDefaultBackendFactory = provider.getFactory();
+            }
+            if (provider.isSystemDefaultCachingBackend()) {
+                systemDefaultCachingBackendFactory = provider.getFactory();
+            }
+            if (provider.isSystemDefaultSearchBackend()) {
+                systemDefaultSearchBackendFactory = provider.getFactory();
+            }
+        }
+        areSystemDefaultsCalculated = true;
+    }
+    
+    private static IQueryBackendFactory getSystemDefaultBackend() {
+        if (!areSystemDefaultsCalculated) {
+            calculateSystemDefaultBackends();
+        }
+        return Objects.requireNonNull(systemDefaultBackendFactory, "System default backend not found");
+    }
+    
+    private static IQueryBackendFactory getSystemDefaultCachingBackend() {
+        if (!areSystemDefaultsCalculated) {
+            calculateSystemDefaultBackends();
+        }
+        return Objects.requireNonNull(systemDefaultCachingBackendFactory, "System default caching backend not found");
+    }
+    
+    private static IQueryBackendFactory getSystemDefaultSearchBackend() {
+        if (!areSystemDefaultsCalculated) {
+            calculateSystemDefaultBackends();
+        }
+        return Objects.requireNonNull(systemDefaultSearchBackendFactory, "System default search backend not found");
+    }
+    
+    private final QueryEvaluationHint engineDefaultHints;
+    private final IQueryBackendFactory defaultCachingBackendFactory;
+    private final IQueryBackendFactory defaultSearchBackendFactory;
+    /** The default engine options; if options are not defined, this version will be used. */
+    private static ViatraQueryEngineOptions DEFAULT;
+    
+    /**
+     * @since 2.0
+     */
+    public static final ViatraQueryEngineOptions getDefault() {
+        if (DEFAULT == null) {
+            DEFAULT = new Builder().build();
+        }
+        return DEFAULT;
+    }
+    public static final class Builder {
+        private QueryEvaluationHint engineDefaultHints;
+        private IQueryBackendFactory defaultBackendFactory;
+        private IQueryBackendFactory defaultCachingBackendFactory;
+        private IQueryBackendFactory defaultSearchBackendFactory;
+        public Builder() {
+        }
+        public Builder(ViatraQueryEngineOptions from) {
+            this.engineDefaultHints = from.engineDefaultHints;
+            this.defaultBackendFactory = engineDefaultHints.getQueryBackendFactory();
+            this.defaultCachingBackendFactory = from.defaultCachingBackendFactory;
+            this.defaultSearchBackendFactory = from.defaultSearchBackendFactory;
+        }
+        /**
+         * Note that the backend factory in the hint is overridden by a factory added with
+         * {@link #withDefaultBackend(IQueryBackendFactory)}.
+         */
+        public Builder withDefaultHint(QueryEvaluationHint engineDefaultHints) {
+            this.engineDefaultHints = engineDefaultHints;
+            return this;
+        }
+        /**
+         * Note that this backend factory overrides the factory defined by the hint added by
+         * {@link #withDefaultHint(QueryEvaluationHint)}.
+         */
+        public Builder withDefaultBackend(IQueryBackendFactory defaultBackendFactory) {
+            this.defaultBackendFactory = defaultBackendFactory;
+            return this;
+        }
+        /**
+         * @since 2.0
+         */
+        public Builder withDefaultSearchBackend(IQueryBackendFactory defaultSearchBackendFactory) {
+            Preconditions.checkArgument(!defaultSearchBackendFactory.isCaching(), "%s is not a search backend", defaultSearchBackendFactory.getClass());
+            this.defaultSearchBackendFactory = defaultSearchBackendFactory;
+            return this;
+        }
+        
+        public Builder withDefaultCachingBackend(IQueryBackendFactory defaultCachingBackendFactory) {
+            Preconditions.checkArgument(defaultCachingBackendFactory.isCaching(), "%s is not a caching backend", defaultCachingBackendFactory.getClass());
+            this.defaultCachingBackendFactory = defaultCachingBackendFactory;
+            return this;
+        }
+        public ViatraQueryEngineOptions build() {
+            IQueryBackendFactory defaultFactory = getDefaultBackend();
+            QueryEvaluationHint hint = getEngineDefaultHints(defaultFactory);
+            return new ViatraQueryEngineOptions(hint, getDefaultCachingBackend(), getDefaultSearchBackend());
+        }
+        private IQueryBackendFactory getDefaultBackend() {
+            if (defaultBackendFactory != null){
+                return defaultBackendFactory;
+            } else if (engineDefaultHints != null) {
+                return engineDefaultHints.getQueryBackendFactory();
+            } else {
+                return getSystemDefaultBackend();
+            }
+        }
+        private IQueryBackendFactory getDefaultCachingBackend() {
+            if (defaultCachingBackendFactory != null) {
+                return defaultCachingBackendFactory;
+            } else if (defaultBackendFactory != null && defaultBackendFactory.isCaching()) {
+                return defaultBackendFactory;
+            } else {
+                return getSystemDefaultCachingBackend();
+            }
+        }
+        
+        private IQueryBackendFactory getDefaultSearchBackend() {
+            if (defaultSearchBackendFactory != null) {
+                return defaultSearchBackendFactory;
+            } else if (defaultBackendFactory != null && !defaultBackendFactory.isCaching()) {
+                return defaultBackendFactory;
+            } else {
+                return getSystemDefaultSearchBackend();
+            }
+        }
+        private QueryEvaluationHint getEngineDefaultHints(IQueryBackendFactory defaultFactory) {
+            if (engineDefaultHints != null){
+                return engineDefaultHints.overrideBy(new QueryEvaluationHint(null, defaultFactory));
+            } else {
+                return new QueryEvaluationHint(null, defaultFactory);
+            }
+        }
+    }
+    /**
+     * Initializes an option builder with no previously set options.
+     */
+    public static Builder defineOptions() {
+        return new Builder();
+    }
+    /**
+     * Initializes an option builder with settings from an existing configuration.
+     */
+    public static Builder copyOptions(ViatraQueryEngineOptions options) {
+        return new Builder(options);
+    }
+    private ViatraQueryEngineOptions(QueryEvaluationHint engineDefaultHints,
+            IQueryBackendFactory defaultCachingBackendFactory, IQueryBackendFactory defaultSearchBackendFactory) {
+        this.engineDefaultHints = engineDefaultHints;
+        this.defaultCachingBackendFactory = defaultCachingBackendFactory;
+        this.defaultSearchBackendFactory = defaultSearchBackendFactory;
+    }
+    public QueryEvaluationHint getEngineDefaultHints() {
+        return engineDefaultHints;
+    }
+    /**
+     * Returns the configured default backend
+     * 
+     * @return the defaultBackendFactory
+     */
+    public IQueryBackendFactory getDefaultBackendFactory() {
+        switch (engineDefaultHints.getQueryBackendRequirementType()) {
+        case DEFAULT_CACHING:
+            return ViatraQueryEngineOptions.getSystemDefaultCachingBackend();
+        case DEFAULT_SEARCH:
+            return ViatraQueryEngineOptions.getSystemDefaultCachingBackend();
+        case SPECIFIC:
+            return engineDefaultHints.getQueryBackendFactory();
+        case UNSPECIFIED:
+        default:
+            return ViatraQueryEngineOptions.getSystemDefaultBackend();
+        }
+    }
+    /**
+     * Returns the configured default caching backend. If the default backend caches matches, it is usually expected, but
+     * not mandatory for the two default backends to be the same.
+     */
+    public IQueryBackendFactory getDefaultCachingBackendFactory() {
+        return defaultCachingBackendFactory;
+    }
+    
+    /**
+     * Returns the configured default search-based backend. If the default backend is search-based, it is usually expected, but
+     * not mandatory for the two default backends to be the same.
+     * @since 2.0
+     */
+    public IQueryBackendFactory getDefaultSearchBackendFactory() {
+        return defaultSearchBackendFactory;
+    }
+    @Override
+    public String toString() {
+        // TODO defaultCachingBackendFactory is ignored
+        if(Objects.equals(engineDefaultHints, DEFAULT.engineDefaultHints)) 
+            return "defaults";
+        else
+            return engineDefaultHints.toString();
+    }
+    
+    /**
+     * @since 2.0
+     */
+    public IQueryBackendFactory getQueryBackendFactory(QueryEvaluationHint hint) {
+        if (hint == null) {
+            return getDefaultBackendFactory();
+        }
+        switch (hint.getQueryBackendRequirementType()) {
+        case DEFAULT_CACHING: 
+            return getDefaultCachingBackendFactory();
+        case DEFAULT_SEARCH: 
+            return getDefaultSearchBackendFactory();
+        case SPECIFIC:
+            return hint.getQueryBackendFactory();
+        default:
+            return getDefaultBackendFactory();
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryMatcher.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryMatcher.java
new file mode 100644
index 00000000..1ae0c96f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryMatcher.java
@@ -0,0 +1,258 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+/**
+ * Interface for a VIATRA Query matcher associated with a graph pattern.
+ * 
+ * @param <Match>
+ *            the IPatternMatch type representing a single match of this pattern.
+ * @author Bergmann Gábor
+ * @noimplement This interface is not intended to be implemented by clients. Implement BaseMatcher instead.
+ */
+public interface ViatraQueryMatcher<Match extends IPatternMatch> {
+    // REFLECTION
+    /** The pattern that will be matched. */
+    IQuerySpecification<? extends ViatraQueryMatcher<Match>> getSpecification();
+    /** Fully qualified name of the pattern. */
+    String getPatternName();
+    /** Returns the index of the symbolic parameter with the given name. */
+    Integer getPositionOfParameter(String parameterName);
+    /** Returns the array of symbolic parameter names. */
+    List<String> getParameterNames();
+    // ALL MATCHES
+    /**
+     * Returns the set of all pattern matches.
+     * 
+     * @return matches represented as a Match object.
+     */
+    Collection<Match> getAllMatches();
+    /**
+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+     * 
+     * @param partialMatch
+     *            a partial match of the pattern where each non-null field binds the corresponding pattern parameter to
+     *            a fixed value.
+     * @return matches represented as a Match object.
+     */
+    Collection<Match> getAllMatches(Match partialMatch);
+    
+    /**
+     * Returns a stream of all pattern matches.
+     * <p>
+     * <strong>WARNING</strong> If the result set changes while the stream is evaluated, the set of matches included in
+     * the stream are unspecified. In such cases, either rely on {@link #getAllMatches()} or collect the results of the
+     * stream in end-user code.
+     * 
+     * @return matches represented as a Match object.
+     * @since 2.0
+     */
+    Stream<Match> streamAllMatches();
+    
+    /**
+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+     * <p>
+     * <strong>WARNING</strong> If the result set changes while the stream is evaluated, the set of matches included in
+     * the stream are unspecified. In such cases, either rely on {@link #getAllMatches()} or collect the results of the
+     * stream in end-user code.
+     * 
+     * @param partialMatch
+     *            a partial match of the pattern where each non-null field binds the corresponding pattern parameter to
+     *            a fixed value.
+     * @return matches represented as a Match object.
+     * @since 2.0
+     */
+    Stream<Match> streamAllMatches(Match partialMatch);
+    
+    // variant(s) with input binding as pattern-specific parameters: not declared in interface
+    // SINGLE MATCH
+    /**
+     * Returns an arbitrarily chosen pattern match. Neither determinism nor randomness of selection is guaranteed.
+     * 
+     * @return a match represented as a Match object, or an empty Optional if no match is found.
+     * @since 2.0
+     */
+    Optional<Match> getOneArbitraryMatch();
+    /**
+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * 
+     * @param partialMatch
+     *            a partial match of the pattern where each non-null field binds the corresponding pattern parameter to
+     *            a fixed value.
+     * @return a match represented as a Match object, or an empty Optional if no match is found.
+     * @since 2.0
+     */
+    Optional<Match> getOneArbitraryMatch(Match partialMatch);
+    // variant(s) with input binding as pattern-specific parameters: not declared in interface
+    // MATCH CHECKING
+    /**
+     * Indicates whether the query has any kind of matches.
+     * 
+     * @return true if there exists a valid match of the pattern.
+     * @since 1.7
+     */
+    boolean hasMatch();
+    
+    /**
+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match, under
+     * any possible substitution of the unspecified parameters (if any).
+     * 
+     * @param partialMatch
+     *            a (partial) match of the pattern where each non-null field binds the corresponding pattern parameter
+     *            to a fixed value.
+     * @return true if the input is a valid (partial) match of the pattern.
+     */
+    boolean hasMatch(Match partialMatch);
+    // variant(s) with input binding as pattern-specific parameters: not declared in interface
+    // NUMBER OF MATCHES
+    /**
+     * Returns the number of all pattern matches.
+     * 
+     * @return the number of pattern matches found.
+     */
+    int countMatches();
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * 
+     * @param partialMatch
+     *            a partial match of the pattern where each non-null field binds the corresponding pattern parameter to
+     *            a fixed value.
+     * @return the number of pattern matches found.
+     */
+    int countMatches(Match partialMatch);
+    // variant(s) with input binding as pattern-specific parameters: not declared in interface
+    // FOR EACH MATCH
+    /**
+     * Executes the given processor on each match of the pattern.
+     * 
+     * @param processor
+     *            the action that will process each pattern match.
+     * @since 2.0
+     */
+    void forEachMatch(Consumer<? super Match> processor);
+    /**
+     * Executes the given processor on each match of the pattern that conforms to the given fixed values of some
+     * parameters.
+     * 
+     * @param partialMatch
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @param processor
+     *            the action that will process each pattern match.
+     * @since 2.0
+     */
+    void forEachMatch(Match partialMatch, Consumer<? super Match> processor);
+    // variant(s) with input binding as pattern-specific parameters: not declared in interface
+    // FOR ONE ARBITRARY MATCH
+    /**
+     * Executes the given processor on an arbitrarily chosen match of the pattern. Neither determinism nor randomness of
+     * selection is guaranteed.
+     * 
+     * @param processor
+     *            the action that will process the selected match.
+     * @return true if the pattern has at least one match, false if the processor was not invoked
+     * @since 2.0
+     */
+    boolean forOneArbitraryMatch(Consumer<? super Match> processor);
+    /**
+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed
+     * values of some parameters. Neither determinism nor randomness of selection is guaranteed.
+     * 
+     * @param partialMatch
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @param processor
+     *            the action that will process the selected match.
+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was
+     *         not invoked
+     * @since 2.0
+     */
+    boolean forOneArbitraryMatch(Match partialMatch, Consumer<? super Match> processor);
+    // variant(s) with input binding as pattern-specific parameters: not declared in interface
+    
+    /**
+     * Returns an empty, mutable Match for the matcher. 
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input. 
+     * This can be used to call the matcher with a partial match 
+     *  even if the specific class of the matcher or the match is unknown.
+     * 
+     * @return the empty match
+     */
+    Match newEmptyMatch();
+    /**
+     * Returns a new (partial) Match object for the matcher. 
+     * This can be used e.g. to call the matcher with a partial
+     * match. 
+     * 
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * 
+     * @param parameters
+     *            the fixed value of pattern parameters, or null if not bound.
+     * @return the (partial) match object.
+     */
+    Match newMatch(Object... parameters);
+    /**
+     * Retrieve the set of values that occur in matches for the given parameterName.
+     * 
+     * @param parameterName
+     *            name of the parameter for which values are returned
+     * @return the Set of all values for the given parameter, null if the parameter with the given name does not exists,
+     *         empty set if there are no matches
+     */
+    Set<Object> getAllValues(final String parameterName);
+    /**
+     * Retrieve the set of values that occur in matches for the given parameterName, that conforms to the given fixed
+     * values of some parameters.
+     * 
+     * @param parameterName
+     *            name of the parameter for which values are returned
+     * @param partialMatch
+     *            a partial match of the pattern where each non-null field binds the corresponding pattern parameter to
+     *            a fixed value.
+     * @return the Set of all values for the given parameter, null if the parameter with the given name does not exists
+     *         or if the parameter with the given name is set in partialMatch, empty set if there are no matches
+     */
+    Set<Object> getAllValues(final String parameterName, Match partialMatch);
+    /**
+     * Returns the engine that the matcher uses.
+     * 
+     * @return the engine
+     */
+    ViatraQueryEngine getEngine();
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryModelUpdateListener.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryModelUpdateListener.java
new file mode 100644
index 00000000..da8bf87e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryModelUpdateListener.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api;
+/**
+ * Listener interface for model changes affecting different levels of the VIATRA Query architecture.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public interface ViatraQueryModelUpdateListener {
+    /** 
+     * Possible notification levels for changes
+     * 
+     * @author Abel Hegedus
+     *
+     */
+    enum ChangeLevel {
+        NO_CHANGE, MODEL, INDEX, MATCHSET;
+        
+        public ChangeLevel changeOccured(ChangeLevel occuredLevel) {
+            if(this.compareTo(occuredLevel) < 0) {
+                return occuredLevel;
+            } else {
+                return this;
+            }
+        }
+    }
+    /**
+     * Called after each change with also sending the level of change.
+     * Only called if the change level is at least at the level returned by getLevel().
+     * 
+     * @param changeLevel
+     */
+    void notifyChanged(ChangeLevel changeLevel);
+    
+    /**
+     * This may be queried only ONCE (!!!) at the registration of the listener.
+     * 
+     * NOTE: this allows us to only create engine level change providers if there is someone who needs it.
+     * 
+     * @return the change level where you want notifications
+     */
+    ChangeLevel getLevel();
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedEMFPQuery.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedEMFPQuery.java
new file mode 100644
index 00000000..c1fb0622
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedEMFPQuery.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EEnum;
+import org.eclipse.emf.ecore.EEnumLiteral;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import tools.refinery.viatra.runtime.exception.ViatraQueryException;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.BasePQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PVisibility;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.QueryInitializationException;
+/**
+ * Common superclass for EMF-based generated PQueries.
+ * @author Bergmann Gabor
+ *
+ */
+public abstract class BaseGeneratedEMFPQuery extends BasePQuery {
+    public BaseGeneratedEMFPQuery() {
+        this(PVisibility.PUBLIC);
+    }
+    
+    /**
+     * @since 2.0
+     */
+    public BaseGeneratedEMFPQuery(PVisibility visibility) {
+        super(visibility);
+    }
+    
+    protected QueryInitializationException processDependencyException(ViatraQueryException ex) {
+        if (ex.getCause() instanceof QueryInitializationException) 
+            return (QueryInitializationException) ex.getCause();
+        return new QueryInitializationException(
+            "Failed to initialize external dependencies of query specification - see 'caused by' for details.", 
+            null, "Problem with query dependencies.", this, ex);
+    }
+    protected EClassifier getClassifierLiteral(String packageUri, String classifierName) {
+        EPackage ePackage = EPackage.Registry.INSTANCE.getEPackage(packageUri);
+        if (ePackage == null) 
+            throw new QueryInitializationException(
+                    "Query refers to EPackage {1} not found in EPackage Registry.", 
+                    new String[]{packageUri}, 
+                    "Query refers to missing EPackage.", this);
+        EClassifier literal = ePackage.getEClassifier(classifierName);
+        if (literal == null) 
+            throw new QueryInitializationException(
+                    "Query refers to classifier {1} not found in EPackage {2}.", 
+                    new String[]{classifierName, packageUri}, 
+                    "Query refers to missing type in EPackage.", this);
+        return literal;
+    }
+    
+    /**
+     * For parameter type retrieval only.
+     * 
+     * <p>If parameter type declaration is erroneous, we still get a working parameter list (without the type declaration); 
+     *  the exception will be thrown again later when the body is processed.
+     */
+    protected EClassifier getClassifierLiteralSafe(String packageURI, String classifierName) {
+        try {
+            return getClassifierLiteral(packageURI, classifierName);
+        } catch (QueryInitializationException e) {
+            return null;
+        }
+    }
+    protected EStructuralFeature getFeatureLiteral(String packageUri, String className, String featureName) {
+        EClassifier container = getClassifierLiteral(packageUri, className);
+        if (! (container instanceof EClass)) 
+            throw new QueryInitializationException(
+                    "Query refers to EClass {1} in EPackage {2} which turned out not be an EClass.", 
+                    new String[]{className, packageUri}, 
+                    "Query refers to missing EClass.", this);
+        EStructuralFeature feature = ((EClass)container).getEStructuralFeature(featureName);
+        if (feature == null) 
+            throw new QueryInitializationException(
+                    "Query refers to feature {1} not found in EClass {2}.", 
+                    new String[]{featureName, className}, 
+                    "Query refers to missing feature.", this);
+        return feature;
+    }
+    protected EEnumLiteral getEnumLiteral(String packageUri, String enumName, String literalName) {
+        EClassifier enumContainer = getClassifierLiteral(packageUri, enumName);
+        if (! (enumContainer instanceof EEnum)) 
+            throw new QueryInitializationException(
+                    "Query refers to EEnum {1} in EPackage {2} which turned out not be an EEnum.", 
+                    new String[]{enumName, packageUri}, 
+                    "Query refers to missing enumeration type.", this);
+        EEnumLiteral literal = ((EEnum)enumContainer).getEEnumLiteral(literalName);
+        if (literal == null) 
+            throw new QueryInitializationException(
+                    "Query refers to enumeration literal {1} not found in EEnum {2}.", 
+                    new String[]{literalName, enumName}, 
+                    "Query refers to missing enumeration literal.", this);
+        return literal;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedEMFQuerySpecification.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedEMFQuerySpecification.java
new file mode 100644
index 00000000..9956983d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedEMFQuerySpecification.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.impl;
+import tools.refinery.viatra.runtime.api.IPatternMatch;
+import tools.refinery.viatra.runtime.api.ViatraQueryMatcher;
+import tools.refinery.viatra.runtime.api.scope.QueryScope;
+import tools.refinery.viatra.runtime.emf.EMFScope;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+/**
+ * Provides common functionality of pattern-specific generated query specifications over the EMF scope.
+ *
+ * @author Bergmann Gábor
+ * @author Mark Czotter
+ */
+public abstract class BaseGeneratedEMFQuerySpecification<Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> extends
+        BaseQuerySpecification<Matcher> {
+    
+    
+    /**
+     * Instantiates query specification for the given internal query representation.
+     */
+    public BaseGeneratedEMFQuerySpecification(PQuery wrappedPQuery) {
+        super(wrappedPQuery);
+    }
+    
+    @Override
+    public Class<? extends QueryScope> getPreferredScopeClass() {
+        return EMFScope.class;
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedEMFQuerySpecificationWithGenericMatcher.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedEMFQuerySpecificationWithGenericMatcher.java
new file mode 100644
index 00000000..949dd112
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedEMFQuerySpecificationWithGenericMatcher.java
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.impl;
+import tools.refinery.viatra.runtime.api.GenericPatternMatch;
+import tools.refinery.viatra.runtime.api.GenericPatternMatcher;
+import tools.refinery.viatra.runtime.api.GenericQuerySpecification;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.scope.QueryScope;
+import tools.refinery.viatra.runtime.emf.EMFScope;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+/**
+ * Provides common functionality of pattern-specific generated query specifications for without generated
+ * pattern-specific match and matcher classes, including private patterns.
+ * 
+ * @since 1.7
+ *
+ */
+public abstract class BaseGeneratedEMFQuerySpecificationWithGenericMatcher
+        extends GenericQuerySpecification<GenericPatternMatcher> {
+    public BaseGeneratedEMFQuerySpecificationWithGenericMatcher(PQuery wrappedPQuery) {
+        super(wrappedPQuery);
+    }
+    @Override
+    public Class<? extends QueryScope> getPreferredScopeClass() {
+        return EMFScope.class;
+    }
+    @Override
+    protected GenericPatternMatcher instantiate(final ViatraQueryEngine engine) {
+        return defaultInstantiate(engine);
+    }
+    @Override
+    public GenericPatternMatcher instantiate() {
+        return new GenericPatternMatcher(this);
+    }
+    @Override
+    public GenericPatternMatch newEmptyMatch() {
+        return GenericPatternMatch.newEmptyMatch(this);
+    }
+    @Override
+    public GenericPatternMatch newMatch(final Object... parameters) {
+        return GenericPatternMatch.newMatch(this, parameters);
+    }
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedPatternGroup.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedPatternGroup.java
new file mode 100644
index 00000000..2e2a823b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseGeneratedPatternGroup.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Mark Czotter, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.impl;
+import java.util.HashSet;
+import java.util.Set;
+import tools.refinery.viatra.runtime.api.IQuerySpecification;
+/**
+ * @author Mark Czotter
+ * 
+ */
+public abstract class BaseGeneratedPatternGroup extends BaseQueryGroup {
+    @Override
+    public Set<IQuerySpecification<?>> getSpecifications() {
+        return querySpecifications;
+    }
+    /**
+     * Returns {@link IQuerySpecification} objects for handling them as a group. To be filled by constructors of subclasses.
+     */
+    protected Set<IQuerySpecification<?>> querySpecifications = new HashSet<IQuerySpecification<?>>();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseMatcher.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseMatcher.java
new file mode 100644
index 00000000..ad79aafd
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseMatcher.java
@@ -0,0 +1,350 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.impl;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import tools.refinery.viatra.runtime.api.IPatternMatch;
+import tools.refinery.viatra.runtime.api.IQuerySpecification;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.ViatraQueryMatcher;
+import tools.refinery.viatra.runtime.internal.apiimpl.QueryResultWrapper;
+import tools.refinery.viatra.runtime.matchers.backend.IMatcherCapability;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+/**
+ * Base implementation of ViatraQueryMatcher.
+ *
+ * @author Bergmann Gábor
+ *
+ * @param <Match>
+ */
+public abstract class BaseMatcher<Match extends IPatternMatch> extends QueryResultWrapper implements ViatraQueryMatcher<Match> {
+    // FIELDS AND CONSTRUCTOR
+    protected ViatraQueryEngine engine;
+    protected IQuerySpecification<? extends BaseMatcher<Match>> querySpecification;
+    private IMatcherCapability capabilities;
+    /**
+     * @since 1.4
+     */
+    public BaseMatcher(IQuerySpecification<? extends BaseMatcher<Match>> querySpecification) {
+        this.querySpecification = querySpecification;
+        this.querySpecification.getInternalQueryRepresentation().ensureInitialized();
+    }
+    
+    /**
+     * @since 1.4
+     */
+    @Override
+    protected
+    void setBackend(ViatraQueryEngine engine, IQueryResultProvider resultProvider, IMatcherCapability capabilities){
+        this.backend = resultProvider;
+        this.engine = engine;
+        this.capabilities = capabilities;
+    }
+    // ARRAY-BASED INTERFACE
+    /** Converts the array representation of a pattern match to an immutable Match object. */
+    protected abstract Match arrayToMatch(Object[] parameters);
+    /** Converts the array representation of a pattern match to a mutable Match object. */
+    protected abstract Match arrayToMatchMutable(Object[] parameters);
+    /** Converts the Match object of a pattern match to the array representation. */
+    protected Object[] matchToArray(Match partialMatch) {
+        return partialMatch.toArray();
+    }
+    // TODO make me public for performance reasons
+    protected abstract Match tupleToMatch(Tuple t);
+    private Object[] fEmptyArray;
+    protected Object[] emptyArray() {
+        if (fEmptyArray == null)
+            fEmptyArray = new Object[getSpecification().getParameterNames().size()];
+        return fEmptyArray;
+    }
+    // REFLECTION
+    @Override
+    public Integer getPositionOfParameter(String parameterName) {
+        return getSpecification().getPositionOfParameter(parameterName);
+    }
+    @Override
+    public List<String> getParameterNames() {
+        return getSpecification().getParameterNames();
+    }
+    // BASE IMPLEMENTATION
+    @Override
+    public Collection<Match> getAllMatches() {
+        return rawStreamAllMatches(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    @Override
+    public Stream<Match> streamAllMatches() {
+        return rawStreamAllMatches(emptyArray());
+    }
+    /**
+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+     *
+     * @param parameters
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @pre size of input array must be equal to the number of parameters.
+     * @return matches represented as a Match object.
+     * @since 2.0
+     */
+    protected Stream<Match> rawStreamAllMatches(Object[] parameters) {
+        // clones the tuples into a match object to protect the Tuples from modifications outside of the ReteMatcher
+        return backend.getAllMatches(parameters).map(this::tupleToMatch);
+    }
+    @Override
+    public Collection<Match> getAllMatches(Match partialMatch) {
+        return rawStreamAllMatches(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    @Override
+    public Stream<Match> streamAllMatches(Match partialMatch) {
+        return rawStreamAllMatches(partialMatch.toArray());
+    }
+    // with input binding as pattern-specific parameters: not declared in interface
+    @Override
+    public Optional<Match> getOneArbitraryMatch() {
+        return rawGetOneArbitraryMatch(emptyArray());
+    }
+    /**
+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     *
+     * @param parameters
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @pre size of input array must be equal to the number of parameters.
+     * @return a match represented as a Match object, or null if no match is found.
+     * @since 2.0
+     */
+    protected Optional<Match> rawGetOneArbitraryMatch(Object[] parameters) {
+        return backend.getOneArbitraryMatch(parameters).map(this::tupleToMatch);
+    }
+    @Override
+    public Optional<Match> getOneArbitraryMatch(Match partialMatch) {
+        return rawGetOneArbitraryMatch(partialMatch.toArray());
+    }
+    // with input binding as pattern-specific parameters: not declared in interface
+    /**
+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match, under
+     * any possible substitution of the unspecified parameters.
+     *
+     * @param parameters
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @return true if the input is a valid (partial) match of the pattern.
+     */
+    protected boolean rawHasMatch(Object[] parameters) {
+        return backend.hasMatch(parameters);
+    }
+    @Override
+    public boolean hasMatch() {
+        return rawHasMatch(emptyArray());
+    }
+    
+    @Override
+    public boolean hasMatch(Match partialMatch) {
+        return rawHasMatch(partialMatch.toArray());
+    }
+    // with input binding as pattern-specific parameters: not declared in interface
+    @Override
+    public int countMatches() {
+        return rawCountMatches(emptyArray());
+    }
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     *
+     * @param parameters
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @pre size of input array must be equal to the number of parameters.
+     * @return the number of pattern matches found.
+     */
+    protected int rawCountMatches(Object[] parameters) {
+        return backend.countMatches(parameters);
+    }
+    @Override
+    public int countMatches(Match partialMatch) {
+        return rawCountMatches(partialMatch.toArray());
+    }
+    // with input binding as pattern-specific parameters: not declared in interface
+    /**
+     * Executes the given processor on each match of the pattern that conforms to the given fixed values of some
+     * parameters.
+     *
+     * @param parameters
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @pre size of input array must be equal to the number of parameters.
+     * @param action
+     *            the action that will process each pattern match.
+     * @since 2.0
+     */
+    protected void rawForEachMatch(Object[] parameters, Consumer<? super Match> processor) {
+        backend.getAllMatches(parameters).map(this::tupleToMatch).forEach(processor);
+    }
+    @Override
+    public void forEachMatch(Consumer<? super Match> processor) {
+        rawForEachMatch(emptyArray(), processor);
+    }
+    @Override
+    public void forEachMatch(Match match, Consumer<? super Match> processor) {
+        rawForEachMatch(match.toArray(), processor);
+    }
+    // with input binding as pattern-specific parameters: not declared in interface
+    @Override
+    public boolean forOneArbitraryMatch(Consumer<? super Match> processor) {
+        return rawForOneArbitraryMatch(emptyArray(), processor);
+    }
+    @Override
+    public boolean forOneArbitraryMatch(Match partialMatch, Consumer<? super Match> processor) {
+        return rawForOneArbitraryMatch(partialMatch.toArray(), processor);
+    }
+    /**
+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed
+     * values of some parameters. Neither determinism nor randomness of selection is guaranteed.
+     *
+     * @param parameters
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @pre size of input array must be equal to the number of parameters.
+     * @param processor
+     *            the action that will process the selected match.
+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was
+     *         not invoked
+     * @since 2.0
+     */
+    protected boolean rawForOneArbitraryMatch(Object[] parameters, Consumer<? super Match> processor) {
+        return backend.getOneArbitraryMatch(parameters).map(this::tupleToMatch).map(m -> {
+            processor.accept(m);
+            return true;
+        }).orElse(false);
+    }
+    // with input binding as pattern-specific parameters: not declared in interface
+    @Override
+    public Match newEmptyMatch() {
+        return arrayToMatchMutable(new Object[getParameterNames().size()]);
+    }
+    @Override
+    public Match newMatch(Object... parameters) {
+        return arrayToMatch(parameters);
+    }
+    @Override
+    public Set<Object> getAllValues(final String parameterName) {
+        return rawStreamAllValues(getPositionOfParameter(parameterName), emptyArray()).collect(Collectors.toSet());
+    }
+    @Override
+    public Set<Object> getAllValues(final String parameterName, Match partialMatch) {
+        return rawStreamAllValues(getPositionOfParameter(parameterName), partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve a stream of values that occur in matches for the given parameterName, that conforms to the given fixed
+     * values of some parameters.
+     *
+     * @param position
+     *            position of the parameter for which values are returned
+     * @param parameters
+     *            a parameter array corresponding to a partial match of the pattern where each non-null field binds the
+     *            corresponding pattern parameter to a fixed value.
+     * @return the stream of all values in the given position
+     * @throws IllegalArgumentException
+     *             if length of parameters array does not equal to number of parameters
+     * @throws IndexOutOfBoundsException
+     *             if position is not appropriate for the current parameter size
+     * @since 2.0
+     */
+    protected Stream<Object> rawStreamAllValues(final int position, Object[] parameters) {
+        Preconditions.checkElementIndex(position, getParameterNames().size());
+        Preconditions.checkArgument(parameters.length == getParameterNames().size());
+        return rawStreamAllMatches(parameters).map(match -> match.get(position));
+    }
+    /**
+     * Uses an existing set to accumulate all values of the parameter with the given name. Since it is a protected
+     * method, no error checking or input validation is performed!
+     *
+     * @param position
+     *            position of the parameter for which values are returned
+     * @param parameters
+     *            a parameter array corresponding to a partial match of the pattern where each non-null field binds the
+     *            corresponding pattern parameter to a fixed value.
+     * @param accumulator
+     *            the existing set to fill with the values
+     */
+    @SuppressWarnings("unchecked")
+    protected <T> void rawAccumulateAllValues(final int position, Object[] parameters, final Set<T> accumulator) {
+        rawForEachMatch(parameters, match -> accumulator.add((T) match.get(position)));
+    }
+    
+    @Override
+    public ViatraQueryEngine getEngine() {
+        return engine;
+    }
+    @Override
+    public IQuerySpecification<? extends BaseMatcher<Match>> getSpecification() {
+        return querySpecification;
+    }
+    @Override
+    public String getPatternName() {
+        return querySpecification.getFullyQualifiedName();
+    }
+    /**
+     * @since 1.4
+     */
+    public IMatcherCapability getCapabilities() {
+        return capabilities;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BasePatternMatch.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BasePatternMatch.java
new file mode 100644
index 00000000..7690daf6
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BasePatternMatch.java
@@ -0,0 +1,115 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.impl;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import tools.refinery.viatra.runtime.api.IPatternMatch;
+/**
+ * Base implementation of IPatternMatch.
+ * 
+ * @author Bergmann Gábor
+ * 
+ */
+public abstract class BasePatternMatch implements IPatternMatch {
+    @SafeVarargs
+    protected static <T> List<T> makeImmutableList(T... elements) {
+        return Collections.unmodifiableList(Arrays.asList(elements));
+    }
+    
+    public static String prettyPrintValue(Object o) {
+        if (o == null) {
+            return "(null)";
+        }
+        String name = prettyPrintFeature(o, "name");
+        if (name != null) {
+            return name;
+        }
+        /*
+         * if (o instanceof EObject) { EStructuralFeature feature = ((EObject)o).eClass().getEStructuralFeature("name");
+         * if (feature != null) { Object name = ((EObject)o).eGet(feature); if (name != null) return name.toString(); }
+         * }
+         */
+        return o.toString();
+    }
+    public static String prettyPrintFeature(Object o, String featureName) {
+        if (o instanceof EObject) {
+            EStructuralFeature feature = ((EObject) o).eClass().getEStructuralFeature(featureName);
+            if (feature != null) {
+                Object value = ((EObject) o).eGet(feature);
+                if (value != null) {
+                    return value.toString();
+                }
+            }
+        }
+        return null;
+    }
+    // TODO performance can be improved here somewhat
+    @Override
+    public Object get(int position) {
+        if (position >= 0 && position < parameterNames().size())
+            return get(parameterNames().get(position));
+        else
+            return null;
+    }
+    @Override
+    public boolean set(int position, Object newValue) {
+        if (!isMutable()) throw new UnsupportedOperationException();
+        if (position >= 0 && position < parameterNames().size()) {
+            return set(parameterNames().get(position), newValue);
+        } else {
+            return false;
+        }
+    }
+    @Override
+    public String toString() {
+        return "Match<" + patternName() + ">{" + prettyPrint() + "}";
+    }
+    
+    @Override
+    public boolean isCompatibleWith(IPatternMatch other) {
+        if(other == null) {
+            return true;
+        }
+        // we assume that the pattern is set for this match!
+        if (!specification().equals(other.specification())) {
+            return false;
+        }
+        for (int i = 0; i < parameterNames().size(); i++) {
+            Object value = get(i);
+            Object otherValue = other.get(i);
+            if(value != null && otherValue != null && !value.equals(otherValue)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    @Override
+    public String patternName() {
+        return specification().getFullyQualifiedName();
+    }
+    @Override
+    public List<String> parameterNames() {
+        return specification().getParameterNames();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseQueryGroup.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseQueryGroup.java
new file mode 100644
index 00000000..b92727e7
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseQueryGroup.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Mark Czotter, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.impl;
+import tools.refinery.viatra.runtime.api.AdvancedViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.IQueryGroup;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+/**
+ * Base implementation of {@link IQueryGroup}.
+ *
+ * @author Mark Czotter
+ *
+ */
+public abstract class BaseQueryGroup implements IQueryGroup {
+    @Override
+    public void prepare(ViatraQueryEngine engine) {
+        prepare(AdvancedViatraQueryEngine.from(engine));
+    }
+    
+    protected void prepare(AdvancedViatraQueryEngine engine) {
+        engine.prepareGroup(this, null /* default options */);
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseQuerySpecification.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseQuerySpecification.java
new file mode 100644
index 00000000..bee4b93d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/BaseQuerySpecification.java
@@ -0,0 +1,147 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.impl;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.api.IPatternMatch;
+import tools.refinery.viatra.runtime.api.IQuerySpecification;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.ViatraQueryMatcher;
+import tools.refinery.viatra.runtime.exception.ViatraQueryException;
+import tools.refinery.viatra.runtime.matchers.psystem.annotations.PAnnotation;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.QueryInitializationException;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery.PQueryStatus;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PVisibility;
+/**
+ * Base implementation of IQuerySpecification.
+ *
+ * @author Gabor Bergmann
+ *
+ */
+public abstract class BaseQuerySpecification<Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> implements
+        IQuerySpecification<Matcher> {
+    /**
+     * @since 1.6
+     */
+    protected static ViatraQueryException processInitializerError(ExceptionInInitializerError err) {
+        Throwable cause1 = err.getCause();
+        if (cause1 instanceof RuntimeException) {
+            Throwable cause2 = ((RuntimeException) cause1).getCause();
+            if (cause2 instanceof ViatraQueryException) {
+                return (ViatraQueryException) cause2;
+            } else if (cause2 instanceof QueryInitializationException) {
+                return new ViatraQueryException((QueryInitializationException) cause2);
+            } 
+        }
+        throw err;
+    }
+    protected final PQuery wrappedPQuery;
+    
+    protected abstract Matcher instantiate(ViatraQueryEngine engine);
+    /**
+     * For backward compatibility of code generated with previous versions of viatra query, this method has a default
+     * implementation returning null, indicating that a matcher can only be created using the old method, which ignores
+     * the hints provided by the user.
+     * 
+     * @since 1.4
+     */
+    @Override
+    public Matcher instantiate() {
+        return null;
+    }
+    
+    
+    /**
+     * Instantiates query specification for the given internal query representation.
+     */
+    public BaseQuerySpecification(PQuery wrappedPQuery) {
+        super();
+        this.wrappedPQuery = wrappedPQuery;
+        wrappedPQuery.publishedAs().add(this);
+    }
+    @Override
+    public PQuery getInternalQueryRepresentation() {
+        return wrappedPQuery;
+    }
+    @Override
+    public Matcher getMatcher(ViatraQueryEngine engine) {
+        ensureInitializedInternal();
+        if (wrappedPQuery.getStatus() == PQueryStatus.ERROR) {
+            String errorMessages = wrappedPQuery.getPProblems().stream()
+                    .map(input -> (input == null) ? "" : input.getShortMessage()).collect(Collectors.joining("\n"));
+            throw new ViatraQueryException(String.format("Erroneous query specification: %s %n %s", getFullyQualifiedName(), errorMessages),
+                    "Cannot initialize matchers on erroneous query specifications.");
+        } else if (!engine.getScope().isCompatibleWithQueryScope(this.getPreferredScopeClass())) {
+            throw new ViatraQueryException(
+                    String.format(
+                            "Scope class incompatibility: the query %s is formulated over query scopes of class %s, "
+                                    + " thus the query engine formulated over scope %s of class %s cannot evaluate it.",
+                            this.getFullyQualifiedName(), this.getPreferredScopeClass().getCanonicalName(),
+                            engine.getScope(), engine.getScope().getClass().getCanonicalName()),
+                    "Incompatible scope classes of engine and query.");
+        }
+        return instantiate(engine);
+    }
+    protected void ensureInitializedInternal() {
+        wrappedPQuery.ensureInitialized();
+    }
+    
+    // // DELEGATIONS
+    
+    @Override
+    public List<PAnnotation> getAllAnnotations() {
+        return wrappedPQuery.getAllAnnotations();
+    }
+    @Override
+    public List<PAnnotation> getAnnotationsByName(String annotationName) {
+        return wrappedPQuery.getAnnotationsByName(annotationName);
+    }
+    @Override
+    public Optional<PAnnotation> getFirstAnnotationByName(String annotationName) {
+        return wrappedPQuery.getFirstAnnotationByName(annotationName);
+    }
+    @Override
+    public String getFullyQualifiedName() {
+        return wrappedPQuery.getFullyQualifiedName();
+    }
+    @Override
+    public List<String> getParameterNames() {
+        return wrappedPQuery.getParameterNames();
+    }
+    @Override
+    public List<PParameter> getParameters() {
+        return wrappedPQuery.getParameters();
+    }
+    @Override
+    public Integer getPositionOfParameter(String parameterName) {
+        return wrappedPQuery.getPositionOfParameter(parameterName);
+    }
+    /**
+     * @since 2.0
+     */
+    @Override
+    public PVisibility getVisibility() {
+        return wrappedPQuery.getVisibility();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/RunOnceQueryEngine.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/RunOnceQueryEngine.java
new file mode 100644
index 00000000..a97dea5d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/impl/RunOnceQueryEngine.java
@@ -0,0 +1,140 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.impl;
+import java.util.Collection;
+import org.eclipse.emf.common.notify.Notifier;
+import tools.refinery.viatra.runtime.api.AdvancedViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.IPatternMatch;
+import tools.refinery.viatra.runtime.api.IQuerySpecification;
+import tools.refinery.viatra.runtime.api.IRunOnceQueryEngine;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.ViatraQueryMatcher;
+import tools.refinery.viatra.runtime.api.ViatraQueryModelUpdateListener;
+import tools.refinery.viatra.runtime.base.api.BaseIndexOptions;
+import tools.refinery.viatra.runtime.emf.EMFScope;
+/**
+ * Run-once query engines can be used to retrieve the current match set of query specifications
+ * in a given scope. The engine is initialized with a {@link Notifier} as scope and a base index options
+ * that specifically allows traversing derived features that are not well-behaving.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public class RunOnceQueryEngine implements IRunOnceQueryEngine {
+    /**
+     * If the model changes, we know that a resampling is required.
+     * 
+     * @author Abel Hegedus
+     *
+     */
+    private final class RunOnceSamplingModelUpdateListener implements ViatraQueryModelUpdateListener {
+        @Override
+        public void notifyChanged(ChangeLevel changeLevel) {
+            // any model change may require re-sampling
+            reSamplingNeeded = true;
+        }
+        @Override
+        public ChangeLevel getLevel() {
+            return ChangeLevel.MODEL;
+        }
+    }
+    /**
+     * Override the default base index options to allow traversing and indexing derived features
+     * that would be problematic in incremental evaluation.
+     * 
+     * @author Abel Hegedus
+     *
+     */
+    private static final class RunOnceBaseIndexOptions extends BaseIndexOptions {
+        
+        public RunOnceBaseIndexOptions() {
+            this.traverseOnlyWellBehavingDerivedFeatures = false;
+        }
+        
+    }
+    /**
+     * The scope of the engine that is used when creating one-time {@link ViatraQueryEngine}s.
+     */
+    private Notifier notifier;
+    /**
+     * The options that are used for initializing the {@link ViatraQueryEngine}.
+     */
+    private RunOnceBaseIndexOptions baseIndexOptions;
+    private AdvancedViatraQueryEngine engine;
+    private boolean reSamplingNeeded = false;
+    protected boolean samplingMode = false;
+    private RunOnceSamplingModelUpdateListener modelUpdateListener;
+    /**
+     * Creates a run-once query engine on the given notifier.
+     */
+    public RunOnceQueryEngine(Notifier notifier) {
+        this.notifier = notifier;
+        this.baseIndexOptions = new RunOnceBaseIndexOptions();
+    }
+    
+    @Override
+    public <Match extends IPatternMatch> Collection<Match> getAllMatches(
+            IQuerySpecification<? extends ViatraQueryMatcher<Match>> querySpecification) {
+        
+        if(samplingMode && reSamplingNeeded && engine != null) {
+            // engine exists from earlier, but may need resampling if model changed
+            engine.getBaseIndex().resampleDerivedFeatures();
+        } else {
+            // create new engine if it doesn't exists
+            //TODO correct scope handling
+            engine = AdvancedViatraQueryEngine.createUnmanagedEngine(new EMFScope(notifier, baseIndexOptions));
+        }
+        ViatraQueryMatcher<Match> matcher = engine.getMatcher(querySpecification);
+        Collection<Match> allMatches = matcher.getAllMatches();
+        if(samplingMode) {
+            engine.addModelUpdateListener(modelUpdateListener);
+        } else {
+            engine.dispose();
+            engine = null;
+        }
+        return allMatches;
+    }
+    
+    @Override
+    public BaseIndexOptions getBaseIndexOptions() {
+        return baseIndexOptions;
+    }
+    @Override
+    public Notifier getScope() {
+        return notifier;
+    }
+    @Override
+    public void setAutomaticResampling(boolean automaticResampling) {
+        samplingMode = automaticResampling;
+        if(automaticResampling) {
+            if (modelUpdateListener == null) {
+                modelUpdateListener = new RunOnceSamplingModelUpdateListener();
+            }
+        } else if(engine != null) {
+            engine.dispose();
+            engine = null;
+        }
+    }
+    @Override
+    public void resampleOnNextCall() {
+        reSamplingNeeded = true;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IBaseIndex.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IBaseIndex.java
new file mode 100644
index 00000000..1795a8ef
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IBaseIndex.java
@@ -0,0 +1,91 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.scope;
+import java.lang.reflect.InvocationTargetException;
+import java.util.concurrent.Callable;
+/**
+ * Represents the index maintained on the model.
+ * @author Bergmann Gabor
+ * @since 0.9
+ * 
+ */
+public interface IBaseIndex {
+    // TODO lightweightObserver?
+    // TODO ViatraBaseIndexChangeListener?
+    
+    /**
+     * The given callback will be executed, and all model traversals and index registrations will be delayed until the
+     * execution is done. If there are any outstanding feature, class or datatype registrations, a single coalesced model
+     * traversal will initialize the caches and deliver the notifications.
+     * 
+     * @param callable
+     */
+    public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException;
+    
+    /**
+     * Adds a coarse-grained listener that will be invoked after the NavigationHelper index or the underlying model is changed. Can be used
+     * e.g. to check model contents. Not intended for general use.
+     * 
+     * <p/> See {@link #removeBaseIndexChangeListener(ViatraBaseIndexChangeListener)}
+     * @param listener
+     */
+    public void addBaseIndexChangeListener(ViatraBaseIndexChangeListener listener);
+    
+    /**
+     * Removes a registered listener.
+     * 
+     * <p/> See {@link #addBaseIndexChangeListener(ViatraBaseIndexChangeListener)}
+     * 
+     * @param listener
+     */
+    public void removeBaseIndexChangeListener(ViatraBaseIndexChangeListener listener);
+    
+    /**
+     * Updates the value of indexed derived features that are not well-behaving.
+     */
+    void resampleDerivedFeatures();
+    /**
+     * Adds a listener for internal errors in the index. A listener can only be added once.
+     * @param listener
+     * @returns true if the listener was not already added
+     * @since 0.8.0
+     */
+    boolean addIndexingErrorListener(IIndexingErrorListener listener);
+    /**
+     * Removes a listener for internal errors in the index
+     * @param listener
+     * @returns true if the listener was successfully removed (e.g. it did exist)
+     * @since 0.8.0
+     */
+    boolean removeIndexingErrorListener(IIndexingErrorListener listener);
+    /**
+     * Register a lightweight observer that is notified if any edge starting at the given Object changes.
+     * 
+     * @param observer the listener instance
+     * @param observedObject the observed instance object
+     * @return false if no observer can be registered for the given instance (e.g. it is a primitive), 
+     *  or observer was already registered (call has no effect)
+     */
+    public boolean addInstanceObserver(IInstanceObserver observer, Object observedObject);
+    
+    /**
+     * Unregisters a lightweight observer for the given Object.
+     * 
+     * @param observer the listener instance
+     * @param observedObject the observed instance object
+     * @return false if no observer can be registered for the given instance (e.g. it is a primitive), 
+     *  or no observer was registered previously (call has no effect)
+     */
+    public boolean removeInstanceObserver(IInstanceObserver observer, Object observedObject);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IEngineContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IEngineContext.java
new file mode 100644
index 00000000..55060853
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IEngineContext.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.scope;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+/**
+ * The context of the engine is instantiated by the scope, 
+ * and provides information and services regarding the model the towards the engine.  
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public interface IEngineContext {
+    
+    /**
+     * Returns the base index. 
+     * @throws ViatraQueryRuntimeException if the base index cannot be accessed 
+     */ 
+    IBaseIndex getBaseIndex();
+    /**
+     * Disposes this context object. Resources in the index may now be freed up.
+     * No more methods should be called after this one.
+     * 
+     * @throws IllegalStateException if there are any active listeners to the underlying index
+     */
+    void dispose();
+    /**
+     * Provides instance model information for pattern matching.
+     * 
+     * <p> Implementors note: must be reentrant. 
+     * If called while index loading is already in progress, must return the single runtime context instance that will eventually index the model. 
+     * When the runtime query context is invoked in such a case, incomplete indexes are tolerable, but change notifications must be correctly provided as loading commences. 
+     * 
+     * @return a runtime context for pattern matching
+     * @since 1.2
+     * @throws ViatraQueryRuntimeException if the runtime context cannot be initialized
+     */
+    public IQueryRuntimeContext getQueryRuntimeContext();
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IIndexingErrorListener.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IIndexingErrorListener.java
new file mode 100644
index 00000000..d144bba6
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IIndexingErrorListener.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.scope;
+import tools.refinery.viatra.runtime.base.api.NavigationHelper;
+/**
+ * 
+ * This interface contains callbacks for various internal errors from the {@link NavigationHelper base index}.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 0.9
+ *
+ */
+public interface IIndexingErrorListener {
+    void error(String description, Throwable t);
+    void fatal(String description, Throwable t);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IInstanceObserver.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IInstanceObserver.java
new file mode 100644
index 00000000..8ef29cbe
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/IInstanceObserver.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.scope;
+/**
+ * Listener interface for lightweight observation of changes in edges leaving from given source instance elements.
+ * @author Bergmann Gabor
+ * @since 0.9
+ *
+ */
+public interface IInstanceObserver {
+    void notifyBinaryChanged(Object sourceElement, Object edgeType);
+    void notifyTernaryChanged(Object sourceElement, Object edgeType);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/QueryScope.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/QueryScope.java
new file mode 100644
index 00000000..5456b9ea
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/QueryScope.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.scope;
+import tools.refinery.viatra.runtime.api.IQuerySpecification;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+import tools.refinery.viatra.runtime.internal.apiimpl.EngineContextFactory;
+/**
+ * Defines a scope for a VIATRA Query engine, which determines the set of model elements that query evaluation operates on.
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public abstract class QueryScope extends EngineContextFactory {
+    
+    /**
+     * Determines whether a query engine initialized on this scope can evaluate queries formulated against the given scope type.
+     * <p> Every query scope class is compatible with a query engine initialized on a scope of the same class or a subclass.
+     * @param queryScopeClass the scope class returned by invoking {@link IQuerySpecification#getPreferredScopeClass()} on a query specification
+     * @return true if an {@link ViatraQueryEngine} initialized on this scope can consume an {@link IQuerySpecification}
+     */
+    public boolean isCompatibleWithQueryScope(Class<? extends QueryScope> queryScopeClass) {
+        return queryScopeClass.isAssignableFrom(this.getClass());
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/ViatraBaseIndexChangeListener.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/ViatraBaseIndexChangeListener.java
new file mode 100644
index 00000000..b746e637
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/scope/ViatraBaseIndexChangeListener.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.api.scope;
+/**
+ * Listener interface for change notifications from the VIATRA Base index.
+ * 
+ * @author Abel Hegedus
+ * @since 0.9
+ *
+ */
+public interface ViatraBaseIndexChangeListener {
+    /**
+     * NOTE: it is possible that this method is called only ONCE! Consider returning a constant value that is set in the constructor.
+     * 
+     * @return true, if the listener should be notified only after index changes, false if notification is needed after each model change 
+     */
+    public boolean onlyOnIndexChange();
+    
+    /**
+     * Called after a model change is handled by the VIATRA Base index and if <code>indexChanged == onlyOnIndexChange()</code>.
+     *  
+     * @param indexChanged true, if the model change also affected the contents of the base index
+     */
+    public void notifyChanged(boolean indexChanged);
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/DynamicEMFQueryRuntimeContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/DynamicEMFQueryRuntimeContext.java
new file mode 100644
index 00000000..a6da213e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/DynamicEMFQueryRuntimeContext.java
@@ -0,0 +1,47 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.base.api.NavigationHelper;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+/**
+ * In dynamic EMF mode, we need to make sure that EEnum literal constants and values returned by eval() expressions 
+ *      are canonicalized in the same way as enum literals from the EMF model.
+ * 
+ * <p> This canonicalization is a one-way mapping, so 
+ *      {@link #unwrapElement(Object)} and {@link #unwrapTuple(Object)} remain NOPs.
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public class DynamicEMFQueryRuntimeContext extends EMFQueryRuntimeContext {
+    public DynamicEMFQueryRuntimeContext(NavigationHelper baseIndex, Logger logger, EMFScope emfScope) {
+        super(baseIndex, logger, emfScope);
+    }   
+    
+    @Override
+    public Object wrapElement(Object externalElement) {
+        return baseIndex.toCanonicalValueRepresentation(externalElement);
+    }
+    
+    @Override
+    public Tuple wrapTuple(Tuple externalElements) {
+        Object[] elements = externalElements.getElements();
+        for (int i=0; i< elements.length; ++i)
+            elements[i] = wrapElement(elements[i]);
+        return Tuples.flatTupleOf(elements);
+    }
+    
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFBaseIndexWrapper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFBaseIndexWrapper.java
new file mode 100644
index 00000000..433c5f72
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFBaseIndexWrapper.java
@@ -0,0 +1,160 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf;
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import tools.refinery.viatra.runtime.api.scope.IBaseIndex;
+import tools.refinery.viatra.runtime.api.scope.IIndexingErrorListener;
+import tools.refinery.viatra.runtime.api.scope.IInstanceObserver;
+import tools.refinery.viatra.runtime.api.scope.ViatraBaseIndexChangeListener;
+import tools.refinery.viatra.runtime.base.api.EMFBaseIndexChangeListener;
+import tools.refinery.viatra.runtime.base.api.IEMFIndexingErrorListener;
+import tools.refinery.viatra.runtime.base.api.LightweightEObjectObserver;
+import tools.refinery.viatra.runtime.base.api.NavigationHelper;
+/**
+ * Wraps the EMF base index into the IBaseIndex interface.
+ * @author Bergmann Gabor
+ *
+ */
+public class EMFBaseIndexWrapper implements IBaseIndex {
+    private final NavigationHelper navigationHelper;
+    /**
+     * @return the underlying index object
+     */
+    public NavigationHelper getNavigationHelper() {
+        return navigationHelper;
+    }
+    /**
+     * @param navigationHelper
+     */
+    public EMFBaseIndexWrapper(NavigationHelper navigationHelper) {
+        this.navigationHelper = navigationHelper;
+    }
+    @Override
+    public void resampleDerivedFeatures() {
+        navigationHelper.resampleDerivedFeatures();
+    }
+    @Override
+    public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException {
+        return navigationHelper.coalesceTraversals(callable);
+    }
+    Map<IIndexingErrorListener, IEMFIndexingErrorListener> indexErrorListeners =
+            new HashMap<IIndexingErrorListener, IEMFIndexingErrorListener>();
+    @Override
+    public boolean addIndexingErrorListener(final IIndexingErrorListener listener) {
+        if (indexErrorListeners.containsKey(listener)) return false;
+        IEMFIndexingErrorListener emfListener = new IEMFIndexingErrorListener() {
+            @Override
+            public void fatal(String description, Throwable t) {
+                listener.fatal(description, t);
+            }
+            @Override
+            public void error(String description, Throwable t) {
+                listener.error(description, t);
+            }
+        };
+        indexErrorListeners.put(listener, emfListener);
+        return navigationHelper.addIndexingErrorListener(emfListener);
+    }
+    @Override
+    public boolean removeIndexingErrorListener(IIndexingErrorListener listener) {
+        if (!indexErrorListeners.containsKey(listener)) return false;
+        return navigationHelper.removeIndexingErrorListener(indexErrorListeners.remove(listener));
+    }
+    
+    
+    Map<ViatraBaseIndexChangeListener, EMFBaseIndexChangeListener> indexChangeListeners = 
+            new HashMap<ViatraBaseIndexChangeListener, EMFBaseIndexChangeListener>();
+    @Override
+    public void addBaseIndexChangeListener(final ViatraBaseIndexChangeListener listener) {
+        EMFBaseIndexChangeListener emfListener = new EMFBaseIndexChangeListener() {
+            @Override
+            public boolean onlyOnIndexChange() {
+                return listener.onlyOnIndexChange();
+            }
+            
+            @Override
+            public void notifyChanged(boolean indexChanged) {
+                listener.notifyChanged(indexChanged);
+            }
+        };
+        indexChangeListeners.put(listener, emfListener);
+        navigationHelper.addBaseIndexChangeListener(emfListener);
+    }
+    @Override
+    public void removeBaseIndexChangeListener(ViatraBaseIndexChangeListener listener) {
+        final EMFBaseIndexChangeListener cListener = indexChangeListeners.remove(listener);
+        if (cListener != null) 
+            navigationHelper.removeBaseIndexChangeListener(cListener);
+    }
+    Map<IInstanceObserver, EObjectObserver> instanceObservers = 
+                new HashMap<IInstanceObserver, EObjectObserver>();
+    @Override
+    public boolean addInstanceObserver(final IInstanceObserver observer,
+            Object observedObject) {
+        if (observedObject instanceof EObject) {
+            EObjectObserver emfObserver = instanceObservers.computeIfAbsent(observer, EObjectObserver::new);
+            boolean success = 
+                    navigationHelper.addLightweightEObjectObserver(emfObserver, (EObject) observedObject);
+            if (success) emfObserver.usageCount++;
+            return success;
+        } else return false;
+    }
+    @Override
+    public boolean removeInstanceObserver(IInstanceObserver observer,
+            Object observedObject) {
+        if (observedObject instanceof EObject) {
+            EObjectObserver emfObserver = instanceObservers.get(observer);
+            if (emfObserver == null)
+                return false;
+            boolean success = 
+                    navigationHelper.removeLightweightEObjectObserver(emfObserver, (EObject)observedObject);
+            if (success) 
+                if (0 == --emfObserver.usageCount)
+                    instanceObservers.remove(observer);
+            return success;
+        } else return false;
+    }
+    private static class EObjectObserver implements LightweightEObjectObserver {
+        /**
+         * 
+         */
+        private final IInstanceObserver observer;
+        int usageCount = 0; 
+        /**
+         * @param observer
+         */
+        private EObjectObserver(IInstanceObserver observer) {
+            this.observer = observer;
+        }
+        @Override
+        public void notifyFeatureChanged(EObject host,
+                EStructuralFeature feature, Notification notification) {
+            observer.notifyBinaryChanged(host, feature);
+        }
+    }
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFEngineContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFEngineContext.java
new file mode 100644
index 00000000..5fe9e23a
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFEngineContext.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Denes Harmath, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.notify.Notifier;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.scope.IBaseIndex;
+import tools.refinery.viatra.runtime.api.scope.IEngineContext;
+import tools.refinery.viatra.runtime.api.scope.IIndexingErrorListener;
+import tools.refinery.viatra.runtime.base.api.ViatraBaseFactory;
+import tools.refinery.viatra.runtime.base.api.NavigationHelper;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+/**
+ * Implements an engine context on EMF models.
+ * @author Bergmann Gabor
+ *
+ */
+class EMFEngineContext implements IEngineContext {
+    private final EMFScope emfScope;
+    ViatraQueryEngine engine;
+    Logger logger;
+    NavigationHelper navHelper;
+    IBaseIndex baseIndex;
+    IIndexingErrorListener taintListener;
+    private EMFQueryRuntimeContext runtimeContext;
+    
+    public EMFEngineContext(EMFScope emfScope, ViatraQueryEngine engine, IIndexingErrorListener taintListener, Logger logger) {
+        this.emfScope = emfScope;
+        this.engine = engine;
+        this.logger = logger;
+        this.taintListener = taintListener;
+    }
+    
+    /**
+     * @throws ViatraQueryRuntimeException thrown if the navigation helper cannot be initialized
+     */
+    public NavigationHelper getNavHelper() {
+        return getNavHelper(true);
+    }
+    
+    private NavigationHelper getNavHelper(boolean ensureInitialized) {
+        if (navHelper == null) {
+            // sync to avoid crazy compiler reordering which would matter if derived features use VIATRA and call this
+            // reentrantly
+            synchronized (this) {
+                navHelper = ViatraBaseFactory.getInstance().createNavigationHelper(null, this.emfScope.getOptions(),
+                        logger);
+                getBaseIndex().addIndexingErrorListener(taintListener);
+            }
+            if (ensureInitialized) {
+                ensureIndexLoaded();
+            }
+        }
+        return navHelper;
+    }
+    private void ensureIndexLoaded() {
+        for (Notifier scopeRoot : this.emfScope.getScopeRoots()) {
+            navHelper.addRoot(scopeRoot);
+        }
+    }
+    @Override
+    public IQueryRuntimeContext getQueryRuntimeContext() {
+        NavigationHelper nh = getNavHelper(false);
+        if (runtimeContext == null) {
+            runtimeContext = 
+                    emfScope.getOptions().isDynamicEMFMode() ?
+                     new DynamicEMFQueryRuntimeContext(nh, logger, emfScope) :
+                     new EMFQueryRuntimeContext(nh, logger, emfScope);
+                     
+             ensureIndexLoaded();
+        }
+        
+        return runtimeContext;
+    }
+    
+    @Override
+    public void dispose() {
+        if (runtimeContext != null) runtimeContext.dispose();
+        if (navHelper != null) navHelper.dispose();
+        
+        this.baseIndex = null;
+        this.engine = null;
+        this.logger = null;
+        this.navHelper = null;
+    }
+    
+    
+    @Override
+    public IBaseIndex getBaseIndex() {
+        if (baseIndex == null) {
+            final NavigationHelper navigationHelper = getNavHelper();
+            baseIndex = new EMFBaseIndexWrapper(navigationHelper);
+        }
+        return baseIndex;
+    }
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFQueryMetaContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFQueryMetaContext.java
new file mode 100644
index 00000000..c316d308
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFQueryMetaContext.java
@@ -0,0 +1,405 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.EcorePackage;
+import tools.refinery.viatra.runtime.emf.types.BaseEMFTypeKey;
+import tools.refinery.viatra.runtime.emf.types.EClassTransitiveInstancesKey;
+import tools.refinery.viatra.runtime.emf.types.EClassUnscopedTransitiveInstancesKey;
+import tools.refinery.viatra.runtime.emf.types.EDataTypeInSlotsKey;
+import tools.refinery.viatra.runtime.emf.types.EStructuralFeatureInstancesKey;
+import tools.refinery.viatra.runtime.matchers.context.AbstractQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.InputKeyImplication;
+import tools.refinery.viatra.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+/**
+ * The meta context information for EMF scopes.
+ * 
+ * <p> The runtime context may specialize answers with a given scope. 
+ * In a static context, a conservative default version ({@link #DEFAULT}) can be used instead. 
+ * 
+ * <p> TODO generics? 
+ * @author Bergmann Gabor
+ *
+ */
+public final class EMFQueryMetaContext extends AbstractQueryMetaContext {
+    
+    /**
+     * Default static instance that only makes conservative assumptions that are valid for any {@link EMFScope} (but not if objects are used).
+     * @since 1.6
+     */
+    public static final EMFQueryMetaContext DEFAULT = new EMFQueryMetaContext(false, true, UnscopedTypeSupport.EMIT_ALWAYS);
+    
+    /**
+     * Default static instance that only makes conservative assumptions that are valid for any scope, even with surrogate objects.
+     * Unscoped types are used for inference, but not emitted as replacement candidates, as they cannot be checked at runtime.
+     * @since 2.1
+     */
+    public static final EMFQueryMetaContext DEFAULT_SURROGATE = new EMFQueryMetaContext(false, true, UnscopedTypeSupport.EMIT_EXCEPT_AS_WEAKENED_REPLACEMENT);
+    
+    private static final EClass EOBJECT_CLASS = 
+            EcorePackage.eINSTANCE.getEObject();
+    private static final EClassTransitiveInstancesKey EOBJECT_SCOPED_KEY = 
+            new EClassTransitiveInstancesKey(EOBJECT_CLASS);
+    private static final EClassUnscopedTransitiveInstancesKey EOBJECT_UNSCOPED_KEY = 
+            new EClassUnscopedTransitiveInstancesKey(EOBJECT_CLASS);
+    private boolean assumeNonDangling;
+    private boolean subResourceScopeSplit;
+    private UnscopedTypeSupport emitUnscopedEClassTypes;
+    
+    private enum UnscopedTypeSupport {
+        EMIT_ALWAYS,
+        EMIT_EXCEPT_AS_WEAKENED_REPLACEMENT,
+        EMIT_NEVER
+    }
+    /**
+     * Instantiates a specialized meta information that is aware of scope-specific details.
+     * Note that this API is not stable and thus non-public.
+     * 
+     * @param assumeNonDangling assumes that all cross-references are non-dangling (do not lead out of scope), no matter what
+     * @param subResourceScopeSplit the scope granularity may be finer than resource-level, i.e. proxy-non-resolving references can lead out of scope
+     * @param emitUnscopedEClassTypes if requested, the metacontext will suppress unscoped input keys; this is recommended if surrogates are used instead of EObjects  
+     */
+    EMFQueryMetaContext(boolean assumeNonDangling, boolean subResourceScopeSplit, UnscopedTypeSupport emitUnscopedEClassTypes) {
+        this.assumeNonDangling = assumeNonDangling;
+        this.subResourceScopeSplit = subResourceScopeSplit;
+        this.emitUnscopedEClassTypes = emitUnscopedEClassTypes;
+    }
+    
+    /**
+     * Instantiates a specialized meta information that is aware of scope-specific details.
+     * @since 2.1
+     */ 
+    public EMFQueryMetaContext(EMFScope scope) {
+        this(scope.getOptions().isDanglingFreeAssumption(), 
+                scope.getScopeRoots().size()==1 && scope.getScopeRoots().iterator().next() instanceof EObject,
+                        UnscopedTypeSupport.EMIT_ALWAYS);
+    }
+    
+    @Override
+    public boolean isEnumerable(IInputKey key) {                
+        ensureValidKey(key);
+        return key.isEnumerable();
+//              if (key instanceof JavaTransitiveInstancesKey) 
+//                      return false;
+//              else
+//                      return true;
+    }
+    
+    @Override
+    public boolean canLeadOutOfScope(IInputKey key) {
+        ensureValidKey(key);
+        if (key instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeature feature = ((EStructuralFeatureInstancesKey) key).getEmfKey();
+            if (feature instanceof EReference){
+                return canLeadOutOfScope((EReference) feature);
+            }
+        }
+        return false;
+    }
+    /**
+     * Tells whether the given reference may lead out of scope.
+     * @since 2.1
+     */
+    public boolean canLeadOutOfScope(EReference reference) {
+        // Is it possible that this edge is dangling, i.e. its target lies outside of the scope?
+        // Unless non-dangling is globally assumed,
+        // proxy-resolving references (incl. containment) might point to proxies and are thus considered unsafe.
+        // Additionally, if the scope is sub-resource (containment subtree of object),
+        // all non-containment edges are also unsafe.
+        // Note that in case of cross-resource containment,
+        // the scope includes the contained object even if it is in a foreign resource.
+        return (!assumeNonDangling)
+                && (reference.isResolveProxies() || (subResourceScopeSplit && !reference.isContainment()));
+    }
+    
+    @Override
+    public boolean isStateless(IInputKey key) {
+        ensureValidKey(key);
+        return key instanceof JavaTransitiveInstancesKey || key instanceof EClassUnscopedTransitiveInstancesKey;
+    }
+    @Override
+    public Map<Set<Integer>, Set<Integer>> getFunctionalDependencies(IInputKey key) {
+        ensureValidKey(key);
+        if (key instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeature feature = ((EStructuralFeatureInstancesKey) key).getEmfKey();
+            final Map<Set<Integer>, Set<Integer>> result = 
+                    new HashMap<Set<Integer>, Set<Integer>>();
+            if (isFeatureMultiplicityToOne(feature))
+                result.put(Collections.singleton(0), Collections.singleton(1));
+            if (isFeatureMultiplicityOneTo(feature))
+                result.put(Collections.singleton(1), Collections.singleton(0));
+            return result;
+        } else {
+            return Collections.emptyMap();
+        }
+    }
+    
+    /**
+     * @since 2.1
+     */
+    public EClassTransitiveInstancesKey getSourceTypeKey(EStructuralFeatureInstancesKey key) {
+        return new EClassTransitiveInstancesKey(key.getEmfKey().getEContainingClass());
+    }
+    /**
+     * @since 2.1
+     */
+    public IInputKey getTargetTypeKey(EStructuralFeatureInstancesKey key) {
+        EStructuralFeature feature = key.getEmfKey();
+        if (feature instanceof EAttribute) {
+            return new EDataTypeInSlotsKey(((EAttribute) feature).getEAttributeType());            
+        } else if (feature instanceof EReference) {
+            EClass eReferenceType = ((EReference) feature).getEReferenceType();
+            if (canLeadOutOfScope(key)) {
+                return new EClassUnscopedTransitiveInstancesKey(eReferenceType);            
+            } else {
+                return new EClassTransitiveInstancesKey(eReferenceType);            
+            }
+        } else throw new IllegalArgumentException();
+    }
+    
+    @Override
+    public Collection<InputKeyImplication> getImplications(IInputKey implyingKey) {
+        ensureValidKey(implyingKey);
+        Collection<InputKeyImplication> result = new HashSet<InputKeyImplication>();
+        if (implyingKey instanceof EClassTransitiveInstancesKey) {
+            EClass eClass = ((EClassTransitiveInstancesKey) implyingKey).getEmfKey();
+            // direct eSuperClasses
+            EList<EClass> directSuperTypes = eClass.getESuperTypes();
+            if (!directSuperTypes.isEmpty()) {
+                for (EClass superType : directSuperTypes) {
+                    final EClassTransitiveInstancesKey implied = new EClassTransitiveInstancesKey(superType);
+                    result.add(new InputKeyImplication(implyingKey, implied, Arrays.asList(0)));
+                }
+            } else {
+                if (!EOBJECT_SCOPED_KEY.equals(implyingKey)) {
+                    result.add(new InputKeyImplication(implyingKey, EOBJECT_SCOPED_KEY, Arrays.asList(0)));
+                }
+            }
+            // implies unscoped
+            if (UnscopedTypeSupport.EMIT_NEVER != emitUnscopedEClassTypes) 
+                result.add(new InputKeyImplication(implyingKey, 
+                    new EClassUnscopedTransitiveInstancesKey(eClass),
+                    Arrays.asList(0)));
+        } else if (implyingKey instanceof EClassUnscopedTransitiveInstancesKey) {
+            EClass eClass = ((EClassUnscopedTransitiveInstancesKey) implyingKey).getEmfKey();
+            // direct eSuperClasses
+            EList<EClass> directSuperTypes = eClass.getESuperTypes();
+            if (!directSuperTypes.isEmpty()) {
+                for (EClass superType : directSuperTypes) {
+                    final EClassUnscopedTransitiveInstancesKey implied = new EClassUnscopedTransitiveInstancesKey(
+                            superType);
+                    result.add(new InputKeyImplication(implyingKey, implied, Arrays.asList(0)));
+                }
+            } else {
+                if (!EOBJECT_UNSCOPED_KEY.equals(implyingKey)) {
+                    result.add(new InputKeyImplication(implyingKey, EOBJECT_UNSCOPED_KEY, Arrays.asList(0)));
+                }
+            }
+        } else if (implyingKey instanceof JavaTransitiveInstancesKey) {
+            Class<?> instanceClass = ((JavaTransitiveInstancesKey) implyingKey).getInstanceClass();
+            if (instanceClass != null) { // resolution successful
+                // direct Java superClass
+                Class<?> superclass = instanceClass.getSuperclass();
+                if (superclass != null) {
+                    JavaTransitiveInstancesKey impliedSuper = new JavaTransitiveInstancesKey(superclass);
+                    result.add(new InputKeyImplication(implyingKey, impliedSuper, Arrays.asList(0)));
+                }
+                // direct Java superInterfaces
+                for (Class<?> superInterface : instanceClass.getInterfaces()) {
+                    if (superInterface != null) {
+                        JavaTransitiveInstancesKey impliedInterface = new JavaTransitiveInstancesKey(superInterface);
+                        result.add(new InputKeyImplication(implyingKey, impliedInterface, Arrays.asList(0)));
+                    }
+                }
+            }
+        } else if (implyingKey instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeature feature = ((EStructuralFeatureInstancesKey) implyingKey).getEmfKey();
+            // source and target type
+            final EClass sourceType = featureSourceType(feature);
+            final EClassTransitiveInstancesKey impliedSource = new EClassTransitiveInstancesKey(sourceType);
+            final EClassifier targetType = featureTargetType(feature);
+            final IInputKey impliedTarget;
+            if (feature instanceof EReference) {
+                EReference reference = (EReference) feature;
+                if (!canLeadOutOfScope(reference)) {
+                    impliedTarget = new EClassTransitiveInstancesKey((EClass) targetType);
+                } else {
+                    impliedTarget = (UnscopedTypeSupport.EMIT_NEVER != emitUnscopedEClassTypes) ? 
+                                    new EClassUnscopedTransitiveInstancesKey((EClass) targetType)
+                                    : null;
+                }
+            } else { // EDatatype
+                impliedTarget = new EDataTypeInSlotsKey((EDataType) targetType);
+            }
+            result.add(new InputKeyImplication(implyingKey, impliedSource, Arrays.asList(0)));
+            if (impliedTarget != null)
+                result.add(new InputKeyImplication(implyingKey, impliedTarget, Arrays.asList(1)));
+            // opposite
+            EReference opposite = featureOpposite(feature);
+            if (opposite != null && !canLeadOutOfScope((EReference) feature)) {
+                EStructuralFeatureInstancesKey impliedOpposite = new EStructuralFeatureInstancesKey(opposite);
+                result.add(new InputKeyImplication(implyingKey, impliedOpposite, Arrays.asList(1, 0)));
+            }
+            // containment
+            // TODO
+        } else if (implyingKey instanceof EDataTypeInSlotsKey) {
+            EDataType dataType = ((EDataTypeInSlotsKey) implyingKey).getEmfKey();
+            // instance class of datatype
+            // TODO this can have a generation gap! (could be some dynamic EMF impl or whatever)
+            Class<?> instanceClass = dataType.getInstanceClass();
+            if (instanceClass != null) {
+                JavaTransitiveInstancesKey implied = new JavaTransitiveInstancesKey(instanceClass);
+                result.add(new InputKeyImplication(implyingKey, implied, Arrays.asList(0)));
+            }
+        } else {
+            illegalInputKey(implyingKey);
+        }
+        return result;
+    }
+    
+    @Override
+    public Map<InputKeyImplication, Set<InputKeyImplication>> getConditionalImplications(IInputKey implyingKey) {
+        ensureValidKey(implyingKey);
+        if (implyingKey instanceof EClassUnscopedTransitiveInstancesKey) {
+            EClass emfKey = ((EClassUnscopedTransitiveInstancesKey) implyingKey).getEmfKey();
+            
+            Map<InputKeyImplication, Set<InputKeyImplication>> result = new HashMap<>();
+            result.put(
+                    new InputKeyImplication(implyingKey, EOBJECT_SCOPED_KEY, Arrays.asList(0)),
+                    new HashSet<>(Arrays.asList(new InputKeyImplication(implyingKey, new EClassTransitiveInstancesKey(emfKey), Arrays.asList(0))))
+            );
+            return result;
+        } else return super.getConditionalImplications(implyingKey);
+    }
+    
+    @Override
+    public Collection<InputKeyImplication> getWeakenedAlternatives(IInputKey implyingKey) {
+        ensureValidKey(implyingKey);
+        if (UnscopedTypeSupport.EMIT_ALWAYS == emitUnscopedEClassTypes && implyingKey instanceof EClassTransitiveInstancesKey) {
+            EClass emfKey = ((EClassTransitiveInstancesKey) implyingKey).getEmfKey();
+            
+            Collection<InputKeyImplication> result = new HashSet<InputKeyImplication>();
+            result.add(
+                    // in some cases, filtering by the the unscoped key may be sufficient
+                    new InputKeyImplication(implyingKey, new EClassUnscopedTransitiveInstancesKey(emfKey), Arrays.asList(0))
+            );
+            return result;
+        } else return super.getWeakenedAlternatives(implyingKey);
+    }
+    public void ensureValidKey(IInputKey key) {
+        if (! (key instanceof BaseEMFTypeKey<?>) && ! (key instanceof JavaTransitiveInstancesKey))
+            illegalInputKey(key);
+    }
+    public void illegalInputKey(IInputKey key) {
+        throw new IllegalArgumentException("The input key " + key + " is not a valid EMF input key.");
+    }
+    
+    public boolean isFeatureMultiplicityToOne(EStructuralFeature feature) {
+        return !feature.isMany();
+    }
+    public boolean isFeatureMultiplicityOneTo(EStructuralFeature typeObject) {
+        if (typeObject instanceof EReference) {
+            final EReference feature = (EReference)typeObject;
+            final EReference eOpposite = feature.getEOpposite();
+            return feature.isContainment() || (eOpposite != null && !eOpposite.isMany());
+        } else return false;
+    }
+    
+    public EClass featureSourceType(EStructuralFeature feature) {
+        return feature.getEContainingClass();
+    }
+    public EClassifier featureTargetType(EStructuralFeature typeObject) {
+        if (typeObject instanceof EAttribute) {
+            EAttribute attribute = (EAttribute) typeObject;
+            return attribute.getEAttributeType();
+        } else if (typeObject instanceof EReference) {
+            EReference reference = (EReference) typeObject;
+            return reference.getEReferenceType();
+        } else
+            throw new IllegalArgumentException("typeObject has invalid type " + typeObject.getClass().getName());
+    }
+    public EReference featureOpposite(EStructuralFeature typeObject) {
+        if (typeObject instanceof EReference) {
+            EReference reference = (EReference) typeObject;
+            return reference.getEOpposite();
+        } else return null;
+    }
+    
+    @Override
+    public Comparator<IInputKey> getSuggestedEliminationOrdering() {
+        return SUGGESTED_ELIMINATION_ORDERING;
+    }
+    private static final Comparator<IInputKey> SUGGESTED_ELIMINATION_ORDERING = new Comparator<IInputKey>() {
+        @Override
+        public int compare(IInputKey o1, IInputKey o2) {
+            if (o1 instanceof EClassTransitiveInstancesKey && o2 instanceof EClassTransitiveInstancesKey) {
+                // common EClass types with many instances should be eliminated before rare types
+                return getRarity((EClassTransitiveInstancesKey)o1) - getRarity((EClassTransitiveInstancesKey)o2);
+            } else {
+                return getKeyTypeEliminationSequence(o1) - getKeyTypeEliminationSequence(o2);
+            }
+        }
+        // The more supertypes there are, the more specialized the type
+        // the more specialized the type, the rarer instances are expected to be found
+        private int getRarity(EClassTransitiveInstancesKey key) {
+            return key.getEmfKey().getEAllSuperTypes().size() + (EOBJECT_SCOPED_KEY.equals(key) ? 0 : 1);
+        }
+        // Scoped EClass transitive instance keys are attempted to be eliminated before all else
+        //  so that e.g. their unscoped version can eliminate them is variable is known to be scoped
+        private int getKeyTypeEliminationSequence(IInputKey o1) {
+            return (o1 instanceof EClassTransitiveInstancesKey) ? -1 : 0;
+        }
+    };
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFQueryRuntimeContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFQueryRuntimeContext.java
new file mode 100644
index 00000000..7809cd24
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFQueryRuntimeContext.java
@@ -0,0 +1,839 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import tools.refinery.viatra.runtime.base.api.DataTypeListener;
+import tools.refinery.viatra.runtime.base.api.FeatureListener;
+import tools.refinery.viatra.runtime.base.api.IndexingLevel;
+import tools.refinery.viatra.runtime.base.api.InstanceListener;
+import tools.refinery.viatra.runtime.base.api.NavigationHelper;
+import tools.refinery.viatra.runtime.emf.types.EClassTransitiveInstancesKey;
+import tools.refinery.viatra.runtime.emf.types.EClassUnscopedTransitiveInstancesKey;
+import tools.refinery.viatra.runtime.emf.types.EDataTypeInSlotsKey;
+import tools.refinery.viatra.runtime.emf.types.EStructuralFeatureInstancesKey;
+import tools.refinery.viatra.runtime.matchers.context.AbstractQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContextListener;
+import tools.refinery.viatra.runtime.matchers.context.IndexingService;
+import tools.refinery.viatra.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+import tools.refinery.viatra.runtime.matchers.util.Accuracy;
+/**
+ * The EMF-based runtime query context, backed by an IQBase NavigationHelper.
+ * 
+ * @author Bergmann Gabor
+ *
+ * <p> TODO: {@link #ensureIndexed(EClass)} may be inefficient if supertype already cached.
+ * @since 1.4
+ */
+public class EMFQueryRuntimeContext extends AbstractQueryRuntimeContext {
+    protected final NavigationHelper baseIndex;
+    //private BaseIndexListener listener;
+    
+    protected final Map<EClass, EnumSet<IndexingService>> indexedClasses = new HashMap<>();
+    protected final Map<EDataType, EnumSet<IndexingService>> indexedDataTypes = new HashMap<>();
+    protected final Map<EStructuralFeature, EnumSet<IndexingService>> indexedFeatures = new HashMap<>();
+    
+    protected final EMFQueryMetaContext metaContext;
+    protected Logger logger;
+    private EMFScope emfScope;
+    public EMFQueryRuntimeContext(NavigationHelper baseIndex, Logger logger, EMFScope emfScope) {
+        this.baseIndex = baseIndex;
+        this.logger = logger;
+        this.metaContext = new EMFQueryMetaContext(emfScope);
+        this.emfScope = emfScope;
+    }
+    
+    public EMFScope getEmfScope() {
+        return emfScope;
+    }
+    
+    /**
+     * Utility method to add an indexing service to a given key. Returns true if the requested service was
+     * not present before this call.
+     * @param map
+     * @param key
+     * @param service
+     * @return
+     */
+    private static <K> boolean addIndexingService(Map<K, EnumSet<IndexingService>> map, K key, IndexingService service){
+        EnumSet<IndexingService> current = map.get(key);
+        if (current == null){
+            current = EnumSet.of(service);
+            map.put(key, current);
+            return true;
+        }else{
+            return current.add(service);
+        }
+    }
+    
+    public void dispose() {
+        //baseIndex.removeFeatureListener(indexedFeatures, listener);
+        indexedFeatures.clear();
+        //baseIndex.removeInstanceListener(indexedClasses, listener);
+        indexedClasses.clear();
+        //baseIndex.removeDataTypeListener(indexedDataTypes, listener);
+        indexedDataTypes.clear();
+        
+        // No need to remove listeners, as NavHelper will be disposed imminently.
+    }
+    @Override
+    public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException {
+        return baseIndex.coalesceTraversals(callable);
+    }
+    
+    @Override
+    public boolean isCoalescing() {
+        return baseIndex.isCoalescing();
+    }
+    
+    @Override
+    public IQueryMetaContext getMetaContext() {
+        return metaContext;
+    }
+    
+    @Override
+    public void ensureIndexed(IInputKey key, IndexingService service) {
+        ensureEnumerableKey(key);
+        if (key instanceof EClassTransitiveInstancesKey) {
+            EClass eClass = ((EClassTransitiveInstancesKey) key).getEmfKey();
+            ensureIndexed(eClass, service);
+        } else if (key instanceof EDataTypeInSlotsKey) {
+            EDataType dataType = ((EDataTypeInSlotsKey) key).getEmfKey();
+            ensureIndexed(dataType, service);
+        } else if (key instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeature feature = ((EStructuralFeatureInstancesKey) key).getEmfKey();
+            ensureIndexed(feature, service);
+        } else {
+            illegalInputKey(key);
+        }
+    }
+    
+    /**
+     * Retrieve the current registered indexing services for the given key. May not return null,
+     * returns an empty set if no indexing is registered.
+     * 
+     * @since 1.4
+     */
+    protected EnumSet<IndexingService> getCurrentIndexingServiceFor(IInputKey key){
+        ensureEnumerableKey(key);
+        if (key instanceof EClassTransitiveInstancesKey) {
+            EClass eClass = ((EClassTransitiveInstancesKey) key).getEmfKey();
+            EnumSet<IndexingService> is = indexedClasses.get(eClass);
+            return is == null ? EnumSet.noneOf(IndexingService.class) : is; 
+        } else if (key instanceof EDataTypeInSlotsKey) {
+            EDataType dataType = ((EDataTypeInSlotsKey) key).getEmfKey();
+            EnumSet<IndexingService> is =  indexedDataTypes.get(dataType);
+            return is == null ? EnumSet.noneOf(IndexingService.class) : is;
+        } else if (key instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeature feature = ((EStructuralFeatureInstancesKey) key).getEmfKey();
+            EnumSet<IndexingService> is =  indexedFeatures.get(feature);
+            return is == null ? EnumSet.noneOf(IndexingService.class) : is;
+        } else {
+            illegalInputKey(key);
+            return EnumSet.noneOf(IndexingService.class);
+        }
+    }
+    
+    @Override
+    public boolean isIndexed(IInputKey key, IndexingService service) {
+        return getCurrentIndexingServiceFor(key).contains(service);
+    }
+    
+    @Override
+    public boolean containsTuple(IInputKey key, ITuple seed) {
+        ensureValidKey(key);
+        if (key instanceof JavaTransitiveInstancesKey) {
+            Class<?> instanceClass = forceGetWrapperInstanceClass((JavaTransitiveInstancesKey) key);
+            return instanceClass != null && instanceClass.isInstance(seed.get(0));
+        } else if (key instanceof EClassUnscopedTransitiveInstancesKey) {
+            EClass emfKey = ((EClassUnscopedTransitiveInstancesKey) key).getEmfKey();
+            Object candidateInstance = seed.get(0);
+            return candidateInstance instanceof EObject
+                    && baseIndex.isInstanceOfUnscoped((EObject) candidateInstance, emfKey);
+        } else {
+            ensureIndexed(key, IndexingService.INSTANCES);
+            if (key instanceof EClassTransitiveInstancesKey) {
+                EClass eClass = ((EClassTransitiveInstancesKey) key).getEmfKey();
+                // instance check not enough to satisfy scoping, must lookup from index
+                Object candidateInstance = seed.get(0);
+                return candidateInstance instanceof EObject 
+                        && baseIndex.isInstanceOfScoped((EObject) candidateInstance, eClass);
+            } else if (key instanceof EDataTypeInSlotsKey) {
+                EDataType dataType = ((EDataTypeInSlotsKey) key).getEmfKey();
+                return baseIndex.isInstanceOfDatatype(seed.get(0), dataType);
+            } else if (key instanceof EStructuralFeatureInstancesKey) {
+                EStructuralFeature feature = ((EStructuralFeatureInstancesKey) key).getEmfKey();
+                Object sourceCandidate = seed.get(0);
+                return sourceCandidate instanceof EObject 
+                        && baseIndex.isFeatureInstance((EObject) sourceCandidate, seed.get(1), feature);
+            } else {
+                illegalInputKey(key);
+                return false;
+            }
+        }
+    }
+    private Class<?> forceGetWrapperInstanceClass(JavaTransitiveInstancesKey key) {
+        Class<?> instanceClass;
+        try {
+            instanceClass = key.forceGetWrapperInstanceClass();
+        } catch (ClassNotFoundException e) {
+            logger.error("Could not load instance class for type constraint " + key.getWrappedKey(), e);
+            instanceClass = null;
+        }
+        return instanceClass;
+    }
+    
+    @Override
+    public Iterable<Tuple> enumerateTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
+        ensureIndexed(key, IndexingService.INSTANCES);
+        final Collection<Tuple> result = new HashSet<Tuple>();
+        
+        if (key instanceof EClassTransitiveInstancesKey) {
+            EClass eClass = ((EClassTransitiveInstancesKey) key).getEmfKey();
+            
+            if (seedMask.indices.length == 0) { // unseeded
+                return baseIndex.getAllInstances(eClass).stream().map(wrapUnary).collect(Collectors.toSet());
+            } else { // fully seeded
+                Object seedInstance = seedMask.getValue(seed, 0);
+                if (containsTuple(key, seed)) 
+                    result.add(Tuples.staticArityFlatTupleOf(seedInstance));
+            }
+        } else if (key instanceof EDataTypeInSlotsKey) {
+            EDataType dataType = ((EDataTypeInSlotsKey) key).getEmfKey();
+            
+            if (seedMask.indices.length == 0) { // unseeded
+                return baseIndex.getDataTypeInstances(dataType).stream().map(wrapUnary).collect(Collectors.toSet());
+            } else { // fully seeded
+                Object seedInstance = seedMask.getValue(seed, 0);
+                if (containsTuple(key, seed)) 
+                    result.add(Tuples.staticArityFlatTupleOf(seedInstance));
+            }
+        } else if (key instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeature feature = ((EStructuralFeatureInstancesKey) key).getEmfKey();
+            
+            boolean isSourceBound = false;
+            int sourceIndex = -1;
+            boolean isTargetBound = false;
+            int targetIndex = -1;
+            for (int i = 0; i < seedMask.getSize(); i++) {
+                int index = seedMask.indices[i];
+                if (index == 0) {
+                    isSourceBound = true;
+                    sourceIndex = i;
+                } else if (index == 1) {
+                    isTargetBound = true;
+                    targetIndex = i;
+                }
+            }
+            
+            if (!isSourceBound && isTargetBound) { 
+                final Object seedTarget = seed.get(targetIndex);
+                final Set<EObject> results = baseIndex.findByFeatureValue(seedTarget, feature);
+                return results.stream().map(obj -> Tuples.staticArityFlatTupleOf(obj, seedTarget)).collect(Collectors.toSet());
+            } else if (isSourceBound && isTargetBound) { // fully seeded
+                final Object seedSource = seed.get(sourceIndex);
+                final Object seedTarget = seed.get(targetIndex);
+                if (containsTuple(key, seed)) 
+                    result.add(Tuples.staticArityFlatTupleOf(seedSource, seedTarget));
+            } else if (!isSourceBound && !isTargetBound) { // fully unseeded
+                baseIndex.processAllFeatureInstances(feature, (source, target) -> result.add(Tuples.staticArityFlatTupleOf(source, target)));
+            } else if (isSourceBound && !isTargetBound) { 
+                final Object seedSource = seed.get(sourceIndex);
+                final Set<Object> results = baseIndex.getFeatureTargets((EObject) seedSource, feature);
+                return results.stream().map(obj -> Tuples.staticArityFlatTupleOf(seedSource, obj)).collect(Collectors.toSet());
+            } 
+        } else {
+            illegalInputKey(key);
+        }
+        
+        
+        return result;
+    }
+    private static Function<Object, Tuple> wrapUnary = Tuples::staticArityFlatTupleOf;
+    @Override
+    public Iterable<? extends Object> enumerateValues(IInputKey key, TupleMask seedMask, ITuple seed) {
+        ensureIndexed(key, IndexingService.INSTANCES);
+        
+        if (key instanceof EClassTransitiveInstancesKey) {
+            EClass eClass = ((EClassTransitiveInstancesKey) key).getEmfKey();
+            
+            if (seedMask.indices.length == 0) { // unseeded
+                return baseIndex.getAllInstances(eClass);
+            } else {
+                // must be unseeded, this is enumerateValues after all!
+                illegalEnumerateValues(seed.toImmutable());
+            }
+        } else if (key instanceof EDataTypeInSlotsKey) {
+            EDataType dataType = ((EDataTypeInSlotsKey) key).getEmfKey();
+            
+            if (seedMask.indices.length == 0) { // unseeded
+                return baseIndex.getDataTypeInstances(dataType);
+            } else {
+                // must be unseeded, this is enumerateValues after all!
+                illegalEnumerateValues(seed.toImmutable());
+            }
+        } else if (key instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeature feature = ((EStructuralFeatureInstancesKey) key).getEmfKey();
+            
+            boolean isSourceBound = false;
+            int sourceIndex = -1;
+            boolean isTargetBound = false;
+            int targetIndex = -1;
+            for (int i = 0; i < seedMask.getSize(); i++) {
+                int index = seedMask.indices[i];
+                if (index == 0) {
+                    isSourceBound = true;
+                    sourceIndex = i;
+                } else if (index == 1) {
+                    isTargetBound = true;
+                    targetIndex = i;
+                }
+            }
+            
+            if (!isSourceBound && isTargetBound) { 
+                Object seedTarget = seed.get(targetIndex);
+                return baseIndex.findByFeatureValue(seedTarget, feature);
+            } else if (isSourceBound && !isTargetBound) { 
+                Object seedSource = seed.get(sourceIndex);
+                return baseIndex.getFeatureTargets((EObject) seedSource, feature);
+            } else {
+                // must be singly unseeded, this is enumerateValues after all!
+                illegalEnumerateValues(seed.toImmutable());
+            }
+        } else {
+            illegalInputKey(key);
+        }
+        return null;
+    }
+    
+    @Override
+    public int countTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
+        ensureIndexed(key, IndexingService.STATISTICS);
+        
+        if (key instanceof EClassTransitiveInstancesKey) {
+            EClass eClass = ((EClassTransitiveInstancesKey) key).getEmfKey();
+            
+            if (seedMask.indices.length == 0) { // unseeded
+                return baseIndex.countAllInstances(eClass);
+            } else { // fully seeded
+                return (containsTuple(key, seed)) ? 1 : 0;
+            }
+        } else if (key instanceof EDataTypeInSlotsKey) {
+            EDataType dataType = ((EDataTypeInSlotsKey) key).getEmfKey();
+            
+            if (seedMask.indices.length == 0) { // unseeded
+                return baseIndex.countDataTypeInstances(dataType);
+            } else { // fully seeded
+                return (containsTuple(key, seed)) ? 1 : 0;
+            }
+        } else if (key instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeature feature = ((EStructuralFeatureInstancesKey) key).getEmfKey();
+            
+            boolean isSourceBound = false;
+            int sourceIndex = -1;
+            boolean isTargetBound = false;
+            int targetIndex = -1;
+            for (int i = 0; i < seedMask.getSize(); i++) {
+                int index = seedMask.indices[i];
+                if (index == 0) {
+                    isSourceBound = true;
+                    sourceIndex = i;
+                } else if (index == 1) {
+                    isTargetBound = true;
+                    targetIndex = i;
+                }
+            }
+            
+            if (!isSourceBound && isTargetBound) { 
+                final Object seedTarget = seed.get(targetIndex);
+                return baseIndex.findByFeatureValue(seedTarget, feature).size();
+            } else if (isSourceBound && isTargetBound) { // fully seeded
+                return (containsTuple(key, seed)) ? 1 : 0;
+            } else if (!isSourceBound && !isTargetBound) { // fully unseeded
+                return baseIndex.countFeatures(feature);
+            } else if (isSourceBound && !isTargetBound) { 
+                final Object seedSource = seed.get(sourceIndex);
+                return baseIndex.countFeatureTargets((EObject) seedSource, feature);
+            } 
+        } else {
+            illegalInputKey(key);
+        }
+        return 0;
+    }
+    
+    
+    /**
+     * @since 2.1
+     */
+    @Override
+    public Optional<Long> estimateCardinality(IInputKey key, TupleMask groupMask, Accuracy requiredAccuracy) {
+        if (key instanceof EClassTransitiveInstancesKey) {
+            EClass eClass = ((EClassTransitiveInstancesKey) key).getEmfKey();
+            
+            if (isIndexed(key, IndexingService.STATISTICS)) { // exact answer known
+                if (groupMask.indices.length == 0) { // empty projection
+                    return (0 != baseIndex.countAllInstances(eClass)) ? Optional.of(1L) : Optional.of(0L);
+                } else { // unprojected
+                    return Optional.of((long)baseIndex.countAllInstances(eClass));
+                }                
+            } else return Optional.empty(); // TODO use known supertype counts as upper, subtypes as lower bounds
+            
+        } else if (key instanceof EClassUnscopedTransitiveInstancesKey) {
+            EClass eClass = ((EClassUnscopedTransitiveInstancesKey) key).getEmfKey();
+            
+            // can give only lower bound based on the scoped key
+            if (Accuracy.BEST_LOWER_BOUND.atLeastAsPreciseAs(requiredAccuracy)) {
+                return estimateCardinality(new EClassTransitiveInstancesKey(eClass), groupMask, requiredAccuracy);
+            } else return Optional.empty();
+            
+        } else if (key instanceof EDataTypeInSlotsKey) {
+            EDataType dataType = ((EDataTypeInSlotsKey) key).getEmfKey();
+            
+            if (isIndexed(key, IndexingService.STATISTICS)) {
+                if (groupMask.indices.length == 0) { // empty projection
+                    return (0 != baseIndex.countDataTypeInstances(dataType)) ? Optional.of(1L) : Optional.of(0L);
+                } else { // unprojected
+                    return Optional.of((long)baseIndex.countDataTypeInstances(dataType));
+                }                
+            } else return Optional.empty();
+            
+        } else if (key instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeatureInstancesKey featureKey = (EStructuralFeatureInstancesKey) key;
+            EStructuralFeature feature = featureKey.getEmfKey();
+            
+            boolean isSourceSelected = false;
+            boolean isTargetSelected = false;
+            for (int i = 0; i < groupMask.getSize(); i++) {
+                int index = groupMask.indices[i];
+                if (index == 0) {
+                    isSourceSelected = true;
+                } else if (index == 1) {
+                    isTargetSelected = true;
+                }
+            }
+            
+            Optional<Long> sourceTypeUpperEstimate = 
+                    estimateCardinality(metaContext.getSourceTypeKey(featureKey), 
+                            TupleMask.identity(1), Accuracy.BEST_UPPER_BOUND);
+            Optional<Long> targetTypeUpperEstimate = 
+                    estimateCardinality(metaContext.getTargetTypeKey(featureKey), 
+                            TupleMask.identity(1), Accuracy.BEST_UPPER_BOUND);                    
+            if (!isSourceSelected && !isTargetSelected) { // empty projection
+                if (isIndexed(key, IndexingService.STATISTICS)) { // we have exact node counts
+                    return (0 == baseIndex.countFeatures(feature)) ? Optional.of(0L) : Optional.of(1L);
+                } else { // we can still say 0 in a few cases
+                    if (0 == sourceTypeUpperEstimate.orElse(-1L))
+                        return Optional.of(0L);
+                    if (0 == targetTypeUpperEstimate.orElse(-1L))
+                        return Optional.of(0L);
+                                        
+                    return Optional.empty();
+                }
+                
+            } else if (isSourceSelected && !isTargetSelected) { // count sources
+                if (isIndexed(key, IndexingService.INSTANCES)) { // we have instances, therefore feature end counts
+                    return Optional.of((long)(baseIndex.getHoldersOfFeature(feature).size()));
+                } else if (metaContext.isFeatureMultiplicityToOne(feature) && 
+                        isIndexed(key, IndexingService.STATISTICS)) { // count of edges = count of sources due to func. dep.
+                    return Optional.of((long)(baseIndex.countFeatures(feature)));
+                } else if (Accuracy.BEST_UPPER_BOUND.atLeastAsPreciseAs(requiredAccuracy)) { 
+                    // upper bound by source type
+                    Optional<Long> estimate = sourceTypeUpperEstimate;
+                    // total edge counts are another upper bound (even if instances are unindexed) 
+                    if (isIndexed(key, IndexingService.STATISTICS)) { 
+                        estimate = Optional.of(Math.min(
+                                baseIndex.countFeatures(feature), 
+                                estimate.orElse(Long.MAX_VALUE)));
+                    }
+                    return estimate;
+                } else return Optional.empty();
+                
+            } else if (!isSourceSelected /*&& isTargetSelected*/) { // count targets
+                if (isIndexed(key, IndexingService.INSTANCES)) { // we have instances, therefore feature end counts
+                    return Optional.of((long)(baseIndex.getValuesOfFeature(feature).size()));
+                } else if (metaContext.isFeatureMultiplicityOneTo(feature) && 
+                        isIndexed(key, IndexingService.STATISTICS)) { // count of edges = count of targets due to func. dep.
+                    return Optional.of((long)(baseIndex.countFeatures(feature)));
+               } else if (Accuracy.BEST_UPPER_BOUND.atLeastAsPreciseAs(requiredAccuracy)) { // upper bound by target type
+                   // upper bound by target type
+                   Optional<Long> estimate = targetTypeUpperEstimate;                    
+                   // total edge counts are another upper bound (even if instances are unindexed) 
+                   if (isIndexed(key, IndexingService.STATISTICS)) { 
+                       estimate = Optional.of(Math.min(
+                               baseIndex.countFeatures(feature), 
+                               estimate.orElse(Long.MAX_VALUE)));
+                   }
+                   return estimate;
+                } else return Optional.empty();
+                
+            } else { // (isSourceSelected && isTargetSelected) // count edges
+                if (isIndexed(key, IndexingService.STATISTICS)) { // we have exact edge counts
+                    return Optional.of((long)baseIndex.countFeatures(feature));
+                } else if (Accuracy.BEST_UPPER_BOUND.atLeastAsPreciseAs(requiredAccuracy)) { // overestimates may still be available
+                    Optional<Long> estimate = // trivial upper bound: product of source & target type sizes (if available)
+                            (sourceTypeUpperEstimate.isPresent() && targetTypeUpperEstimate.isPresent()) ?
+                                    Optional.of(
+                                            ((long)sourceTypeUpperEstimate.get()) * targetTypeUpperEstimate.get()
+                                    ) : Optional.empty();
+                                    
+                    if (metaContext.isFeatureMultiplicityToOne(feature) && sourceTypeUpperEstimate.isPresent()) { 
+                        // upper bounded by source type due to func. dep.              
+                        estimate = Optional.of(Math.min(
+                                sourceTypeUpperEstimate.get(), 
+                                estimate.orElse(Long.MAX_VALUE)));
+                    }
+                    if (metaContext.isFeatureMultiplicityOneTo(feature) && targetTypeUpperEstimate.isPresent()) { 
+                        // upper bounded by target type due to func. dep.              
+                        estimate = Optional.of(Math.min(
+                                targetTypeUpperEstimate.get(), 
+                                estimate.orElse(Long.MAX_VALUE)));
+                    }
+                    
+                    return estimate;
+                } else return Optional.empty();
+            }
+            
+        } else {
+            return Optional.empty();
+        }
+    }
+    
+    /**
+     * @since 2.1
+     */
+    @Override
+    public Optional<Double> estimateAverageBucketSize(IInputKey key, TupleMask groupMask, Accuracy requiredAccuracy) {
+        // smart handling of special cases
+        if (key instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeatureInstancesKey featureKey = (EStructuralFeatureInstancesKey) key;
+            EStructuralFeature feature = featureKey.getEmfKey();
+            // special treatment for edge navigation
+            if (1 == groupMask.getSize()) {
+                if (0 == groupMask.indices[0] && metaContext.isFeatureMultiplicityToOne(feature)) { // count targets per source
+                    return Optional.of(1.0);
+                } else if (1 == groupMask.indices[0] && metaContext.isFeatureMultiplicityOneTo(feature)) { // count sources per target
+                    return Optional.of(1.0);
+                }
+            }
+        }
+        
+        // keep the default behaviour
+        return super.estimateAverageBucketSize(key, groupMask, requiredAccuracy);
+    }
+    
+    
+    public void ensureEnumerableKey(IInputKey key) {
+        ensureValidKey(key);
+        if (! metaContext.isEnumerable(key))
+            throw new IllegalArgumentException("Key is not enumerable: " + key);
+        
+    }
+    public void ensureValidKey(IInputKey key) {
+        metaContext.ensureValidKey(key);
+    }
+    public void illegalInputKey(IInputKey key) {
+        metaContext.illegalInputKey(key);
+    }
+    public void illegalEnumerateValues(Tuple seed) {
+        throw new IllegalArgumentException("Must have exactly one unseeded element in enumerateValues() invocation, received instead: " + seed);
+    }
+    
+    /**
+     * @since 1.4
+     */
+    public void ensureIndexed(EClass eClass, IndexingService service) {
+        if (addIndexingService(indexedClasses, eClass, service)) {
+            final Set<EClass> newClasses = Collections.singleton(eClass);
+            IndexingLevel level = IndexingLevel.toLevel(service);
+            if (!baseIndex.getIndexingLevel(eClass).providesLevel(level)) {
+                baseIndex.registerEClasses(newClasses, level);
+            }
+            //baseIndex.addInstanceListener(newClasses, listener);
+        }
+    }
+    
+    /**
+     * @since 1.4
+     */
+    public void ensureIndexed(EDataType eDataType, IndexingService service) {
+        if (addIndexingService(indexedDataTypes, eDataType, service)) {
+            final Set<EDataType> newDataTypes = Collections.singleton(eDataType);
+            IndexingLevel level = IndexingLevel.toLevel(service);
+            if (!baseIndex.getIndexingLevel(eDataType).providesLevel(level)) {
+                baseIndex.registerEDataTypes(newDataTypes, level);
+            }
+            //baseIndex.addDataTypeListener(newDataTypes, listener);
+        }
+    }
+    
+    /**
+     * @since 1.4
+     */
+    public void ensureIndexed(EStructuralFeature feature, IndexingService service) {
+        if (addIndexingService(indexedFeatures, feature, service)) {
+            final Set<EStructuralFeature> newFeatures = Collections.singleton(feature);
+            IndexingLevel level = IndexingLevel.toLevel(service);
+            if (!baseIndex.getIndexingLevel(feature).providesLevel(level)) {
+                baseIndex.registerEStructuralFeatures(newFeatures, level);
+            }
+            //baseIndex.addFeatureListener(newFeatures, listener);
+        }
+    }
+    
+    
+    // UPDATE HANDLING SECTION 
+    
+    /**
+     * Abstract internal listener wrapper for a {@link IQueryRuntimeContextListener}. 
+     * Due to the overridden equals/hashCode(), it is safe to create a new instance for the same listener.
+     * 
+     * @author Bergmann Gabor
+     */
+    private abstract static class ListenerAdapter { 
+        IQueryRuntimeContextListener listener;
+        Tuple seed;
+        /**
+         * @param listener
+         * @param seed must be non-null
+         */
+        public ListenerAdapter(IQueryRuntimeContextListener listener, Object... seed) {
+            this.listener = listener;
+            this.seed = Tuples.flatTupleOf(seed);
+        }
+                
+        @Override
+        public int hashCode() {
+            final int prime = 31;
+            int result = 1;
+            result = prime * result
+                    + ((listener == null) ? 0 : listener.hashCode());
+            result = prime * result + ((seed == null) ? 0 : seed.hashCode());
+            return result;
+        }
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj)
+                return true;
+            if (obj == null)
+                return false;
+            if (!(obj.getClass().equals(this.getClass())))
+                return false;
+            ListenerAdapter other = (ListenerAdapter) obj;
+            if (listener == null) {
+                if (other.listener != null)
+                    return false;
+            } else if (!listener.equals(other.listener))
+                return false;
+            if (seed == null) {
+                if (other.seed != null)
+                    return false;
+            } else if (!seed.equals(other.seed))
+                return false;
+            return true;
+        }
+        @Override
+        public String toString() {
+            return "Wrapped<Seed:" + seed + ">#" + listener;
+        }
+        
+        
+    }
+    private static class EClassTransitiveInstancesAdapter extends ListenerAdapter implements InstanceListener {
+        private Object seedInstance;
+        public EClassTransitiveInstancesAdapter(IQueryRuntimeContextListener listener, Object seedInstance) {
+            super(listener, seedInstance);
+            this.seedInstance = seedInstance;
+        }
+        @Override
+        public void instanceInserted(EClass clazz, EObject instance) {
+            if (seedInstance != null && !seedInstance.equals(instance)) return;
+            listener.update(new EClassTransitiveInstancesKey(clazz), 
+                    Tuples.staticArityFlatTupleOf(instance), true);
+        }
+        @Override
+        public void instanceDeleted(EClass clazz, EObject instance) {
+            if (seedInstance != null && !seedInstance.equals(instance)) return;
+            listener.update(new EClassTransitiveInstancesKey(clazz), 
+                    Tuples.staticArityFlatTupleOf(instance), false);
+        }       
+    }
+    private static class EDataTypeInSlotsAdapter extends ListenerAdapter implements DataTypeListener {
+        private Object seedValue;
+        public EDataTypeInSlotsAdapter(IQueryRuntimeContextListener listener, Object seedValue) {
+            super(listener, seedValue);
+            this.seedValue = seedValue;
+        }
+        @Override
+        public void dataTypeInstanceInserted(EDataType type, Object instance,
+                boolean firstOccurrence) {
+            if (firstOccurrence) {
+                if (seedValue != null && !seedValue.equals(instance)) return;
+                listener.update(new EDataTypeInSlotsKey(type), 
+                        Tuples.staticArityFlatTupleOf(instance), true);
+            }
+        }
+        @Override
+        public void dataTypeInstanceDeleted(EDataType type, Object instance,
+                boolean lastOccurrence) {
+            if (lastOccurrence) {
+                if (seedValue != null && !seedValue.equals(instance)) return;
+                listener.update(new EDataTypeInSlotsKey(type), 
+                        Tuples.staticArityFlatTupleOf(instance), false);
+            }
+        }
+    }
+    private static class EStructuralFeatureInstancesKeyAdapter extends ListenerAdapter implements FeatureListener {
+        private Object seedHost;
+        private Object seedValue;
+        public EStructuralFeatureInstancesKeyAdapter(IQueryRuntimeContextListener listener, Object seedHost, Object seedValue) {
+            super(listener, seedHost, seedValue);
+            this.seedHost = seedHost;
+            this.seedValue = seedValue;
+        }
+        @Override
+        public void featureInserted(EObject host, EStructuralFeature feature,
+                Object value) {
+            if (seedHost != null && !seedHost.equals(host)) return;
+            if (seedValue != null && !seedValue.equals(value)) return;
+            listener.update(new EStructuralFeatureInstancesKey(feature), 
+                    Tuples.staticArityFlatTupleOf(host, value), true);
+        }
+        @Override
+        public void featureDeleted(EObject host, EStructuralFeature feature,
+                Object value) {
+            if (seedHost != null && !seedHost.equals(host)) return;
+            if (seedValue != null && !seedValue.equals(value)) return;
+            listener.update(new EStructuralFeatureInstancesKey(feature), 
+                    Tuples.staticArityFlatTupleOf(host, value), false);
+        }       
+    }
+    
+    @Override
+    public void addUpdateListener(IInputKey key, Tuple seed /* TODO ignored */, IQueryRuntimeContextListener listener) {
+        // stateless, so NOP
+        if (key instanceof JavaTransitiveInstancesKey) return;
+        ensureIndexed(key, IndexingService.INSTANCES);
+        if (key instanceof EClassTransitiveInstancesKey) {
+            EClass eClass = ((EClassTransitiveInstancesKey) key).getEmfKey();
+            baseIndex.addInstanceListener(Collections.singleton(eClass), 
+                    new EClassTransitiveInstancesAdapter(listener, seed.get(0)));
+        } else if (key instanceof EDataTypeInSlotsKey) {
+            EDataType dataType = ((EDataTypeInSlotsKey) key).getEmfKey();
+            baseIndex.addDataTypeListener(Collections.singleton(dataType), 
+                    new EDataTypeInSlotsAdapter(listener, seed.get(0)));
+        } else if (key instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeature feature = ((EStructuralFeatureInstancesKey) key).getEmfKey();
+            baseIndex.addFeatureListener(Collections.singleton(feature), 
+                    new EStructuralFeatureInstancesKeyAdapter(listener, seed.get(0), seed.get(1)));
+        } else {
+            illegalInputKey(key);
+        }
+    }
+    @Override
+    public void removeUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) {
+        // stateless, so NOP
+        if (key instanceof JavaTransitiveInstancesKey) return;
+        ensureIndexed(key, IndexingService.INSTANCES);
+        if (key instanceof EClassTransitiveInstancesKey) {
+            EClass eClass = ((EClassTransitiveInstancesKey) key).getEmfKey();
+            baseIndex.removeInstanceListener(Collections.singleton(eClass), 
+                    new EClassTransitiveInstancesAdapter(listener, seed.get(0)));
+        } else if (key instanceof EDataTypeInSlotsKey) {
+            EDataType dataType = ((EDataTypeInSlotsKey) key).getEmfKey();
+            baseIndex.removeDataTypeListener(Collections.singleton(dataType), 
+                    new EDataTypeInSlotsAdapter(listener, seed.get(0)));
+        } else if (key instanceof EStructuralFeatureInstancesKey) {
+            EStructuralFeature feature = ((EStructuralFeatureInstancesKey) key).getEmfKey();
+            baseIndex.removeFeatureListener(Collections.singleton(feature), 
+                    new EStructuralFeatureInstancesKeyAdapter(listener, seed.get(0), seed.get(1)));
+        } else {
+            illegalInputKey(key);
+        }
+    }
+    
+    // TODO wrap / unwrap enum literals 
+    // TODO use this in all other public methods (maybe wrap & delegate?)
+    
+    @Override
+    public Object unwrapElement(Object internalElement) {
+        return internalElement;
+    }
+    @Override
+    public Tuple unwrapTuple(Tuple internalElements) {
+        return internalElements;
+    }
+    @Override
+    public Object wrapElement(Object externalElement) {
+        return externalElement;
+    }
+    @Override
+    public Tuple wrapTuple(Tuple externalElements) {
+        return externalElements;
+    }
+    
+    /**
+     * @since 1.4
+     */
+    @Override
+    public void ensureWildcardIndexing(IndexingService service) {
+        baseIndex.setWildcardLevel(IndexingLevel.toLevel(service));
+    }
+    
+    /**
+     * @since 1.4
+     */
+    @Override
+    public void executeAfterTraversal(Runnable runnable) throws InvocationTargetException {
+        baseIndex.executeAfterTraversal(runnable);
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFScope.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFScope.java
new file mode 100644
index 00000000..dead9716
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/EMFScope.java
@@ -0,0 +1,199 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Denes Harmath, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import tools.refinery.viatra.runtime.api.AdvancedViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.scope.IEngineContext;
+import tools.refinery.viatra.runtime.api.scope.IIndexingErrorListener;
+import tools.refinery.viatra.runtime.api.scope.QueryScope;
+import tools.refinery.viatra.runtime.base.api.BaseIndexOptions;
+import tools.refinery.viatra.runtime.base.api.NavigationHelper;
+import tools.refinery.viatra.runtime.exception.ViatraQueryException;
+/**
+ * An {@link QueryScope} consisting of EMF objects contained in multiple {@link ResourceSet}s, a single {@link ResourceSet}, {@link Resource} or a containment subtree below a given {@link EObject}.
+ * 
+ * <p> The scope is characterized by a root and some options (see {@link BaseIndexOptions}) such as dynamic EMF mode, subtree filtering etc.
+ * <p>
+ * The scope of pattern matching will be the given EMF model root(s) and below (see FAQ for more precise definition).
+ * 
+ * <p> Note on <i>cross-resource containment</i>: in case of {@link EObject} scopes, cross-resource containments will be considered part of the scope.
+ * The same goes for {@link ResourceSet} scopes, provided that the resource of the contained element is successfully loaded into the resource set. 
+ * In case of a {@link Resource} scope, containments pointing out from the resource will be excluded from the scope. 
+ * Thus the boundaries of {@link EObject} scopes conform to the notion of EMF logical containment, while {@link Resource} and {@link ResourceSet} scopes adhere to persistence boundaries.
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public class EMFScope extends QueryScope {
+    
+    private Set<? extends Notifier> scopeRoots;
+    private BaseIndexOptions options;
+    
+    /**
+     * Creates an EMF scope at the given root, with default options (recommended for most users).
+     * @param scopeRoot the root of the EMF scope
+     * @throws ViatraQueryRuntimeException- if scopeRoot is not an EMF ResourceSet, Resource or EObject
+     */
+    public EMFScope(Notifier scopeRoot) {
+        this(Collections.singleton(scopeRoot), new BaseIndexOptions());
+    }
+    /**
+     * Creates an EMF scope at the given root, with customizable options.
+     * <p> Most users should consider {@link #EMFScope(Notifier)} instead.
+     * @param scopeRoot the root of the EMF scope
+     * @param options the base index building settings
+     * @throws ViatraQueryRuntimeException if scopeRoot is not an EMF ResourceSet, Resource or EObject
+     */
+    public EMFScope(Notifier scopeRoot, BaseIndexOptions options) {
+        this(Collections.singleton(scopeRoot), options);
+    }
+    /**
+     * Creates an EMF scope at the given roots, with default options (recommended for most users).
+     * @param scopeRoots the roots of the EMF scope, must be {@link ResourceSet}s
+     * @throws ViatraQueryRuntimeException if not all scopeRoots are {@link ResourceSet}s
+     */
+    public EMFScope(Set<? extends ResourceSet> scopeRoots) {
+        this(scopeRoots, new BaseIndexOptions());
+    }
+    /**
+     * Creates an EMF scope at the given roots, with customizable options.
+     * <p> Most users should consider {@link #EMFScope(Set)} instead.
+     * @param scopeRoots the roots of the EMF scope, must be {@link ResourceSet}s
+     * @param options the base index building settings
+     * @throws ViatraQueryRuntimeException if not all scopeRoots are {@link ResourceSet}s
+     */
+    public EMFScope(Set<? extends Notifier> scopeRoots, BaseIndexOptions options) {
+        super();
+        if (scopeRoots.isEmpty()) {
+            throw new IllegalArgumentException("No scope roots given");
+        } else if (scopeRoots.size() == 1) {
+            checkScopeRoots(scopeRoots, EObject.class::isInstance, Resource.class::isInstance, ResourceSet.class::isInstance);
+        } else {
+            checkScopeRoots(scopeRoots, ResourceSet.class::isInstance);
+        }
+        this.scopeRoots = new HashSet<>(scopeRoots);
+        this.options = options.copy();
+    }
+    @SafeVarargs
+    private final void checkScopeRoots(Set<? extends Notifier> scopeRoots, Predicate<Notifier>... predicates) {
+        for (Notifier scopeRoot : scopeRoots) {
+            // Creating compound predicate that checks the various branches of disjunction together
+            Predicate<Notifier> compoundPredicate = Arrays.stream(predicates).collect(Collectors.reducing(a -> true, a -> a, (a, b) -> a.or(b)));
+            if (!compoundPredicate.test(scopeRoot))
+                throw new ViatraQueryException(ViatraQueryException.INVALID_EMFROOT
+                        + (scopeRoot == null ? "(null)" : scopeRoot.getClass().getName()),
+                        ViatraQueryException.INVALID_EMFROOT_SHORT);
+        }
+    }
+    /**
+     * @return the scope roots ({@link ResourceSet}s) containing the model
+     */
+    public Set<? extends Notifier> getScopeRoots() {
+        return scopeRoots;
+    }
+    
+    /**
+     * @return the options
+     */
+    public BaseIndexOptions getOptions() {
+        return options.copy();
+    }
+    
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((options == null) ? 0 : options.hashCode());
+        result = prime * result
+                + ((scopeRoots == null) ? 0 : scopeRoots.hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof EMFScope))
+            return false;
+        EMFScope other = (EMFScope) obj;
+        if (options == null) {
+            if (other.options != null)
+                return false;
+        } else if (!options.equals(other.options))
+            return false;
+        if (scopeRoots == null) {
+            if (other.scopeRoots != null)
+                return false;
+        } else if (!scopeRoots.equals(other.scopeRoots))
+            return false;
+        return true;
+    }   
+    
+    @Override
+    public String toString() {
+        return String.format("EMFScope(%s):%s", options, scopeRoots.stream().map(this::scopeRootString).collect(Collectors.joining(",")));
+    }
+    
+    private String scopeRootString(Notifier notifier) {
+        if (notifier instanceof Resource) {
+            Resource resource = (Resource) notifier;
+            return String.format("%s(%s)", resource.getClass(), resource.getURI());
+        } else if (notifier instanceof ResourceSet) {
+            ResourceSet resourceSet = (ResourceSet) notifier;
+            return resourceSet.getResources().stream()
+                    .map(Resource::getURI)
+                    .map(URI::toString)
+                    .collect(Collectors.joining(", ", resourceSet.getClass() + "(", ")"));
+        } else {
+            return notifier.toString();
+        }
+    }
+    @Override
+    protected IEngineContext createEngineContext(ViatraQueryEngine engine, IIndexingErrorListener errorListener, Logger logger) {
+        return new EMFEngineContext(this, engine, errorListener, logger);
+    }
+    /**
+     * Provides access to the underlying EMF model index ({@link NavigationHelper}) from a VIATRA Query engine instantiated on an EMFScope
+     * 
+     * @param engine an already existing VIATRA Query engine instantiated on an EMFScope
+     * @return the underlying EMF base index that indexes the contents of the EMF model
+     * @throws ViatraQueryRuntimeException if base index initialization fails
+     */
+    public static NavigationHelper extractUnderlyingEMFIndex(ViatraQueryEngine engine) {
+        final QueryScope scope = engine.getScope();
+         if (scope instanceof EMFScope)
+             return ((EMFBaseIndexWrapper)AdvancedViatraQueryEngine.from(engine).getBaseIndex()).getNavigationHelper();
+         else throw new IllegalArgumentException("Cannot extract EMF base index from VIATRA Query engine instantiated on non-EMF scope " + scope);
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/helper/ViatraQueryRuntimeHelper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/helper/ViatraQueryRuntimeHelper.java
new file mode 100644
index 00000000..93ac97f2
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/helper/ViatraQueryRuntimeHelper.java
@@ -0,0 +1,161 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf.helper;
+import java.util.function.Function;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import tools.refinery.viatra.runtime.api.IPatternMatch;
+/**
+ * Helper functions for dealing with the EMF objects with VIATRA Queries.
+ * 
+ * @author Abel Hegedus
+ * @since 0.9
+ *
+ */
+public class ViatraQueryRuntimeHelper {
+    
+    private ViatraQueryRuntimeHelper() {/*Utility class constructor*/}
+    
+    private static final Function<Object, String> STRING_VALUE_TRANSFORMER = input -> (input == null) ? "(null)" : input.toString();
+    /**
+     * Gives a human-readable name of an EMF type. 
+     */
+    public static String prettyPrintEMFType(Object typeObject) {
+        if (typeObject == null) {
+            return "(null)";
+        } else if (typeObject instanceof EClassifier) {
+            final EClassifier eClassifier = (EClassifier) typeObject;
+            final EPackage ePackage = eClassifier.getEPackage();
+            final String nsURI = ePackage == null ? null : ePackage.getNsURI();
+            final String typeName = eClassifier.getName();
+            return "" + nsURI + "/" + typeName;
+        } else if (typeObject instanceof EStructuralFeature) {
+            final EStructuralFeature feature = (EStructuralFeature) typeObject;
+            return prettyPrintEMFType(feature.getEContainingClass()) + "." + feature.getName();
+        } else
+            return typeObject.toString();
+    }
+    /**
+     * Get the structural feature with the given name of the given object.
+     *
+     * @param o
+     *            the object (must be an EObject)
+     * @param featureName
+     *            the name of the feature
+     * @return the EStructuralFeature of the object or null if it can not be found
+     */
+    public static EStructuralFeature getFeature(Object o, String featureName) {
+        if (o instanceof EObject) {
+            EStructuralFeature feature = ((EObject) o).eClass().getEStructuralFeature(featureName);
+            return feature;
+        }
+        return null;
+    }
+    /**
+     * Returns the message for the given match using the given format. The format string can refer to the value of
+     * parameter A of the match with $A$ and even access features of A (if it's an EObject), e.g. $A.id$.
+     * 
+     * <p/>
+     * If the selected parameter does not exist, the string "[no such parameter]" is added
+     * 
+     * <p/>
+     * If no feature is defined, but A has a feature called "name", then its value is used.
+     * 
+     * <p/>
+     * If the selected feature does not exist, A.toString() is added.
+     * 
+     * <p/>
+     * If the selected feature is null, the string "null" is added.
+     * 
+     * @param match
+     *            cannot be null!
+     * @param messageFormat
+     *            cannot be null!
+     */
+    public static String getMessage(IPatternMatch match, String messageFormat) {
+        return getMessage(match, messageFormat, STRING_VALUE_TRANSFORMER);
+    }
+    
+    /**
+     * Returns the message for the given match using the given format while transforming values with the given function.
+     * The format string can refer to the value of parameter A of the match with $A$ and even access features of A (if
+     * it's an EObject), e.g. $A.id$. The function will be called to compute the final string representation of the
+     * values selected by the message format.
+     * 
+     * <p/>
+     * If the selected parameter does not exist, the string "[no such parameter]" is added
+     * 
+     * <p/>
+     * If no feature is defined, but A has a feature called "name", then its value is passed to the function.
+     * 
+     * <p/>
+     * If the selected feature does not exist, A is passed to the function.
+     * 
+     * <p/>
+     * If the selected feature is null, the string "null" is added.
+     * 
+     * @param match
+     *            cannot be null!
+     * @param messageFormat
+     *            cannot be null!
+     * @param parameterValueTransformer
+     *            cannot be null!
+     * @since 2.0
+     */
+    public static String getMessage(IPatternMatch match, String messageFormat, Function<Object,String> parameterValueTransformer) {
+        String[] tokens = messageFormat.split("\\$");
+        StringBuilder newText = new StringBuilder();
+    
+        for (int i = 0; i < tokens.length; i++) {
+            if (i % 2 == 0) {
+                newText.append(tokens[i]);
+            } else {
+                String[] objectTokens = tokens[i].split("\\.");
+                if (objectTokens.length > 0) {
+                    Object o = null;
+                    EStructuralFeature feature = null;
+    
+                    if (objectTokens.length == 1) {
+                        o = match.get(objectTokens[0]);
+                        feature = getFeature(o, "name");
+                    }
+                    if (objectTokens.length == 2) {
+                        o = match.get(objectTokens[0]);
+                        feature = getFeature(o, objectTokens[1]);
+                    }
+    
+                    if (o != null && feature != null) {
+                        Object value = ((EObject) o).eGet(feature);
+                        if (value != null) {
+                            newText.append(parameterValueTransformer.apply(value));
+                        } else {
+                            newText.append("null");
+                        }
+                    } else if (o != null) {
+                        newText.append(parameterValueTransformer.apply(o));
+                    }
+                } else {
+                    newText.append("[no such parameter]");
+                }
+            }
+        }
+    
+        return newText.toString();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/BaseEMFTypeKey.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/BaseEMFTypeKey.java
new file mode 100644
index 00000000..c5dfa966
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/BaseEMFTypeKey.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf.types;
+import tools.refinery.viatra.runtime.matchers.context.common.BaseInputKeyWrapper;
+/**
+ * Base class for EMF Type keys. 
+ * @author Bergmann Gabor
+ *
+ */
+public abstract class BaseEMFTypeKey<EMFKey> extends BaseInputKeyWrapper<EMFKey> {
+    public BaseEMFTypeKey(EMFKey emfKey) {
+        super(emfKey);
+    }
+    public EMFKey getEmfKey() {
+        return getWrappedKey();
+    }
+    
+    @Override
+    public String toString() {
+        return this.getPrettyPrintableName();
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EClassExactInstancesKey.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EClassExactInstancesKey.java
new file mode 100644
index 00000000..dd10502d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EClassExactInstancesKey.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf.types;
+import org.eclipse.emf.ecore.EClass;
+import tools.refinery.viatra.runtime.emf.EMFScope;
+import tools.refinery.viatra.runtime.emf.helper.ViatraQueryRuntimeHelper;
+/**
+ * Instance tuples are of form (x), where x is an eObject instance of the given eClass, but <b>not</b> one of its subclasses, <b>within the scope</b>.
+ * <p> This input key has the strict semantics that instances must be within the scope.
+ * 
+ * @noreference This class is not intended to be referenced by clients. Not currently supported by {@link EMFScope}, for internal use only at the time
+ * 
+ * @author Bergmann Gabor
+ * @since 2.1
+ */
+public class EClassExactInstancesKey extends BaseEMFTypeKey<EClass> {
+        public EClassExactInstancesKey(EClass emfKey) {
+                super(emfKey);
+        }
+        @Override
+        public String getPrettyPrintableName() {
+        return "(scoped,exact) "+ViatraQueryRuntimeHelper.prettyPrintEMFType(wrappedKey);
+        }
+        @Override
+        public String getStringID() {
+        return "eClass(scoped,exact)#"+ ViatraQueryRuntimeHelper.prettyPrintEMFType(wrappedKey);
+        }
+        @Override
+        public int getArity() {
+                return 1;
+        }
+        @Override
+        public boolean isEnumerable() {
+                return true;
+        }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EClassTransitiveInstancesKey.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EClassTransitiveInstancesKey.java
new file mode 100644
index 00000000..4ca6b220
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EClassTransitiveInstancesKey.java
@@ -0,0 +1,47 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf.types;
+import org.eclipse.emf.ecore.EClass;
+import tools.refinery.viatra.runtime.emf.EMFScope;
+import tools.refinery.viatra.runtime.emf.helper.ViatraQueryRuntimeHelper;
+/**
+ * Instance tuples are of form (x), where x is an eObject instance of the given eClass or one of its subclasses <b>within the scope</b>.
+ * <p> As of version 1.6, this input key has the strict semantics that instances must be within the {@link EMFScope}.
+ * @author Bergmann Gabor
+ *
+ */
+public class EClassTransitiveInstancesKey extends BaseEMFTypeKey<EClass> {
+    public EClassTransitiveInstancesKey(EClass emfKey) {
+        super(emfKey);
+    }
+    @Override
+    public String getPrettyPrintableName() {
+        return "(scoped) "+ViatraQueryRuntimeHelper.prettyPrintEMFType(wrappedKey);
+    }
+    @Override
+    public String getStringID() {
+        return "eClass(scoped)#"+ ViatraQueryRuntimeHelper.prettyPrintEMFType(wrappedKey);
+    }
+    @Override
+    public int getArity() {
+        return 1;
+    }
+    
+    @Override
+    public boolean isEnumerable() {
+        return true;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EClassUnscopedTransitiveInstancesKey.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EClassUnscopedTransitiveInstancesKey.java
new file mode 100644
index 00000000..11c5b235
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EClassUnscopedTransitiveInstancesKey.java
@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf.types;
+import org.eclipse.emf.ecore.EClass;
+import tools.refinery.viatra.runtime.emf.helper.ViatraQueryRuntimeHelper;
+/**
+ * Instance tuples are of form (x), where x is an eObject instance of the given eClass or one of its subclasses <b>regardless whether it is within the scope</b>.
+ * 
+ * @author Bergmann Gabor
+ * @since 1.6 
+ */
+public class EClassUnscopedTransitiveInstancesKey extends BaseEMFTypeKey<EClass> {
+    public EClassUnscopedTransitiveInstancesKey(EClass emfKey) {
+        super(emfKey);
+    }
+    @Override
+    public String getPrettyPrintableName() {
+        return "(unscoped) "+ViatraQueryRuntimeHelper.prettyPrintEMFType(wrappedKey);
+    }
+    @Override
+    public String getStringID() {
+        return "eClass(unscoped)#"+ ViatraQueryRuntimeHelper.prettyPrintEMFType(wrappedKey);
+    }
+    @Override
+    public int getArity() {
+        return 1;
+    }
+    @Override
+    public boolean isEnumerable() {
+        return false;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EDataTypeInSlotsKey.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EDataTypeInSlotsKey.java
new file mode 100644
index 00000000..a1cc4863
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EDataTypeInSlotsKey.java
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf.types;
+import org.eclipse.emf.ecore.EDataType;
+import tools.refinery.viatra.runtime.emf.helper.ViatraQueryRuntimeHelper;
+/**
+ * Instance tuples are of form (x), where x is an instance of the given eDataType residing at an attribute slot of an eObject in the model.
+ * @author Bergmann Gabor
+ *
+ */
+public class EDataTypeInSlotsKey extends BaseEMFTypeKey<EDataType> {
+    /**
+     * @param emfKey
+     */
+    public EDataTypeInSlotsKey(EDataType emfKey) {
+        super(emfKey);
+    }
+    @Override
+    public String getPrettyPrintableName() {
+        return "(Attribute Slot Values: " + ViatraQueryRuntimeHelper.prettyPrintEMFType(wrappedKey) + ")";
+    }
+    @Override
+    public String getStringID() {
+        return "slotValue#" + ViatraQueryRuntimeHelper.prettyPrintEMFType(wrappedKey);
+    }
+    @Override
+    public int getArity() {
+        return 1;
+    }
+    
+    @Override
+    public boolean isEnumerable() {
+        return true;
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EStructuralFeatureInstancesKey.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EStructuralFeatureInstancesKey.java
new file mode 100644
index 00000000..357f5e7e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/emf/types/EStructuralFeatureInstancesKey.java
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.emf.types;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import tools.refinery.viatra.runtime.emf.EMFScope;
+import tools.refinery.viatra.runtime.emf.helper.ViatraQueryRuntimeHelper;
+/**
+ * Instance tuples are of form (x, y), where x is an eObject that has y as the value of the given feature (or one of the values in case of multi-valued).
+ * 
+ * <p> As of version 1.6, this input key has the strict semantics that x must be within the {@link EMFScope}, scoping is <b>not</b> implied for y.
+ * @author Bergmann Gabor
+ *
+ */
+public class EStructuralFeatureInstancesKey extends BaseEMFTypeKey<EStructuralFeature> {
+    
+    public EStructuralFeatureInstancesKey(EStructuralFeature emfKey) {
+        super(emfKey);
+    }
+    @Override
+    public String getPrettyPrintableName() {
+        return ViatraQueryRuntimeHelper.prettyPrintEMFType(wrappedKey);
+    }
+    @Override
+    public String getStringID() {
+        return "feature#"+ getPrettyPrintableName();
+    }
+    @Override
+    public int getArity() {
+        return 2;
+    }
+    
+    @Override
+    public boolean isEnumerable() {
+        return true;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/exception/ViatraQueryException.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/exception/ViatraQueryException.java
new file mode 100644
index 00000000..fec547a6
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/exception/ViatraQueryException.java
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Akos Horvath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.exception;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.QueryInitializationException;
+/**
+ * A general VIATRA Query-related problem during the operation of the VIATRA Query
+ * engine, or the loading, manipulation and evaluation of queries.
+ * 
+ * @author Bergmann Gabor
+ * @since 0.9
+ * 
+ */
+public class ViatraQueryException extends ViatraQueryRuntimeException {
+    private static final long serialVersionUID = -74252748358355750L;
+    public static final String PARAM_NOT_SUITABLE_WITH_NO = "The type of the parameters are not suitable for the operation. Parameter number: ";
+    public static final String CONVERSION_FAILED = "Could not convert the term to the designated type";
+    public static final String CONVERT_NULL_PARAMETER = "Could not convert null to the designated type";
+    public static final String RELATIONAL_PARAM_UNSUITABLE = "The parameters are not acceptable by the operation";
+    /**
+     * @since 0.9
+     */
+    public static final String PROCESSING_PROBLEM = "The following error occurred during the processing of a query (e.g. for the preparation of a VIATRA pattern matcher)";
+    /**
+     * @since 0.9
+     */
+    public static final String QUERY_INIT_PROBLEM = "The following error occurred during the initialization of a VIATRA query specification";
+    public static final String GETNAME_FAILED = "Could not get 'name' attribute of the result";
+    public static final String INVALID_EMFROOT = "Incremental EMF query engine can only be attached on the contents of an EMF EObject, Resource, ResourceSet or multiple ResourceSets. Received instead: ";
+    public static final String INVALID_EMFROOT_SHORT = "Invalid EMF model root";
+    // public static final String EMF_MODEL_PROCESSING_ERROR = "Error while processing the EMF model";
+    private final String shortMessage;
+    public ViatraQueryException(String s, String shortMessage) {
+        super(s);
+        this.shortMessage = shortMessage;
+    }
+    public ViatraQueryException(QueryProcessingException e) {
+        super(PROCESSING_PROBLEM + ": " + e.getMessage(), e);
+        this.shortMessage = e.getShortMessage();
+    }
+    
+    public ViatraQueryException(QueryInitializationException e) {
+        super(QUERY_INIT_PROBLEM + ": " + e.getMessage(), e);
+        this.shortMessage = e.getShortMessage();
+    }
+    public ViatraQueryException(String s, String shortMessage, Throwable e) {
+        super(s + ": " + e.getMessage(), e);
+        this.shortMessage = shortMessage;
+    }
+    public String getShortMessage() {
+        return shortMessage;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/IQueryGroupProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/IQueryGroupProvider.java
new file mode 100644
index 00000000..45594b5b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/IQueryGroupProvider.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.extensibility;
+import java.util.Set;
+import tools.refinery.viatra.runtime.api.IQueryGroup;
+import tools.refinery.viatra.runtime.matchers.util.IProvider;
+/**
+ * Provider interface for {@link IQueryGroup} instances with added method for
+ * requesting the set of FQNs for the query specifications in the group.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public interface IQueryGroupProvider extends IProvider<IQueryGroup> {
+    /**
+     * Note that the provider should load the query group class only if the FQNs can not be computed in other ways.
+     * 
+     * @return the set of query specification FQNs in the group
+     */
+    Set<String> getQuerySpecificationFQNs();
+    /**
+     * Note that the provider should load the query group class only if the FQNs can not be computed in other ways.
+     * 
+     * @return a set of providers for query specifications in the group
+     */
+    Set<IQuerySpecificationProvider> getQuerySpecificationProviders();
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/IQuerySpecificationProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/IQuerySpecificationProvider.java
new file mode 100644
index 00000000..3c9c235d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/IQuerySpecificationProvider.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.extensibility;
+import tools.refinery.viatra.runtime.api.IQuerySpecification;
+import tools.refinery.viatra.runtime.matchers.util.IProvider;
+/**
+ * Provider interface for {@link IQuerySpecification} instances with added method for
+ * requesting the FQN for the query specification.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public interface IQuerySpecificationProvider extends IProvider<IQuerySpecification<?>> {
+    /**
+     * Note that the provider will usually not load the query specification class to return the FQN.
+     * 
+     * @return the fully qualified name of the provided query specification
+     */
+    String getFullyQualifiedName();
+    /**
+     * Returns the name of project providing the specification (or null if not calculable)
+     */
+    String getSourceProjectName();
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/PQueryExtensionFactory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/PQueryExtensionFactory.java
new file mode 100644
index 00000000..91e087d7
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/PQueryExtensionFactory.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.extensibility;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import tools.refinery.viatra.runtime.api.IQuerySpecification;
+/**
+ * An extension factory to access PQuery instances from Query Specifications.
+ * 
+ * @author Zoltan Ujhelyi
+ *
+ */
+public class PQueryExtensionFactory extends SingletonExtensionFactory {
+    @Override
+    public Object create() throws CoreException {
+        final Object _spec = super.create();
+        if (_spec instanceof IQuerySpecification<?>) {
+            return ((IQuerySpecification<?>) _spec).getInternalQueryRepresentation();
+        }
+        throw new CoreException(new Status(IStatus.ERROR, getBundle().getSymbolicName(), "Cannot instantiate PQuery instance."));
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/SingletonExtensionFactory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/SingletonExtensionFactory.java
new file mode 100644
index 00000000..29705968
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/SingletonExtensionFactory.java
@@ -0,0 +1,62 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.extensibility;
+import java.lang.reflect.Method;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExecutableExtension;
+import org.eclipse.core.runtime.IExecutableExtensionFactory;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.Status;
+import org.osgi.framework.Bundle;
+/**
+ * Factory to register a static singleton instance in an extension point. 
+ * 
+ * @author Zoltan Ujhelyi
+ * 
+ */
+public class SingletonExtensionFactory implements IExecutableExtension, IExecutableExtensionFactory {
+    private String clazzName;
+    private Bundle bundle;
+    protected Bundle getBundle() {
+        return bundle;
+    }
+    
+    @Override
+    public Object create() throws CoreException {
+        try {
+            final Class<?> clazz = bundle.loadClass(clazzName);
+            Method method = clazz.getMethod("instance");
+            return method.invoke(null);
+        } catch (Exception e) {
+            throw new CoreException(new Status(IStatus.ERROR, bundle.getSymbolicName(), "Error loading group "
+                    + clazzName, e));
+        }
+    }
+    @Override
+    public void setInitializationData(IConfigurationElement config, String propertyName, Object data)
+            throws CoreException {
+        String id = config.getContributor().getName();
+        bundle = Platform.getBundle(id);
+        if (data instanceof String) {
+            clazzName = (String) data;
+        } else {
+            throw new CoreException(new Status(IStatus.ERROR, bundle.getSymbolicName(),
+                    "Unsupported extension initialization data: " + data));
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/SingletonQueryGroupProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/SingletonQueryGroupProvider.java
new file mode 100644
index 00000000..758b51dd
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/SingletonQueryGroupProvider.java
@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.extensibility;
+import java.util.Set;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.api.IQueryGroup;
+import tools.refinery.viatra.runtime.api.IQuerySpecification;
+import tools.refinery.viatra.runtime.matchers.util.SingletonInstanceProvider;
+/**
+ * Provider implementation for storing an existing query group instance.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public class SingletonQueryGroupProvider extends SingletonInstanceProvider<IQueryGroup> implements IQueryGroupProvider {
+    /**
+     * @param instance the instance to wrap
+     */
+    public SingletonQueryGroupProvider(IQueryGroup instance) {
+        super(instance);
+    }
+    @Override
+    public Set<String> getQuerySpecificationFQNs() {
+        return get().getSpecifications().stream().map(IQuerySpecification::getFullyQualifiedName)
+                .collect(Collectors.toSet());
+    }
+    @Override
+    public Set<IQuerySpecificationProvider> getQuerySpecificationProviders() {
+        return get().getSpecifications().stream().map(SingletonQuerySpecificationProvider::new)
+                .collect(Collectors.toSet());
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/SingletonQuerySpecificationProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/SingletonQuerySpecificationProvider.java
new file mode 100644
index 00000000..f8f3a741
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/SingletonQuerySpecificationProvider.java
@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.extensibility;
+import tools.refinery.viatra.runtime.api.IQuerySpecification;
+import tools.refinery.viatra.runtime.matchers.util.SingletonInstanceProvider;
+/**
+ * Provider implementation for storing an existing query specification instance.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public class SingletonQuerySpecificationProvider extends SingletonInstanceProvider<IQuerySpecification<?>>
+        implements IQuerySpecificationProvider {
+    /**
+     * 
+     * @param instance the instance to wrap
+     */
+    public SingletonQuerySpecificationProvider(IQuerySpecification<?> instance) {
+        super(instance);
+    }
+    @Override
+    public String getFullyQualifiedName() {
+        return get().getFullyQualifiedName();
+    }
+    @Override
+    public String getSourceProjectName() {
+        return null;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/ViatraQueryRuntimeConstants.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/ViatraQueryRuntimeConstants.java
new file mode 100644
index 00000000..9b0850e4
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/extensibility/ViatraQueryRuntimeConstants.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.extensibility;
+/**
+ * Utility class for Viatra Query runtime constants, such as extension point identifiers.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public final class ViatraQueryRuntimeConstants {
+    private ViatraQueryRuntimeConstants() {/* Constructor hidden for utility class */}
+    
+    // Surrogate query extension    
+    
+    public static final String SURROGATE_QUERY_EXTENSIONID = "tools.refinery.viatra.runtime.surrogatequeryemf";
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/ExtensionBasedSurrogateQueryLoader.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/ExtensionBasedSurrogateQueryLoader.java
new file mode 100644
index 00000000..af7cdaf1
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/ExtensionBasedSurrogateQueryLoader.java
@@ -0,0 +1,148 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Abel Hegedus, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.internal;
+import static tools.refinery.viatra.runtime.matchers.util.Preconditions.checkState;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import org.apache.log4j.Logger;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import tools.refinery.viatra.runtime.emf.types.EStructuralFeatureInstancesKey;
+import tools.refinery.viatra.runtime.extensibility.ViatraQueryRuntimeConstants;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.surrogate.SurrogateQueryRegistry;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.util.IProvider;
+/**
+ * @author Abel Hegedus
+ *
+ */
+public class ExtensionBasedSurrogateQueryLoader {
+    private static final String DUPLICATE_SURROGATE_QUERY = "Duplicate surrogate query definition %s for feature %s of EClass %s in package %s (FQN in map %s, contributing plug-ins %s, plug-in %s)";
+    
+    private Map<String, String> contributingPluginOfFeatureMap = new HashMap<>();
+    private Map<EStructuralFeature, PQueryProvider> contributedSurrogateQueries;
+    private static final ExtensionBasedSurrogateQueryLoader INSTANCE = new ExtensionBasedSurrogateQueryLoader();
+    /**
+     * A provider implementation for PQuery instances based on extension elements. It is expected that the getter will only
+     * @author Zoltan Ujhelyi
+     *
+     */
+    private static final class PQueryProvider implements IProvider<PQuery> {
+        private final IConfigurationElement element;
+        private PQuery query;
+        
+        public PQueryProvider(IConfigurationElement element) {
+            this.element = element;
+            this.query = null;
+        }
+        @Override
+        public PQuery get() {
+            try {
+                if (query == null) {
+                    query = (PQuery) element.createExecutableExtension("surrogate-query");
+                }
+                return query;
+            } catch (CoreException e) {
+                throw new IllegalArgumentException("Error initializing surrogate query", e);
+            }
+        }
+    }
+    
+    public static ExtensionBasedSurrogateQueryLoader instance() {
+        return INSTANCE;
+    }
+    public void loadKnownSurrogateQueriesIntoRegistry() {
+        Map<EStructuralFeature, PQueryProvider> knownSurrogateQueryFQNs = getSurrogateQueryProviders();
+        for (Entry<EStructuralFeature, PQueryProvider> entry : knownSurrogateQueryFQNs.entrySet()) {
+            final IInputKey inputKey = new EStructuralFeatureInstancesKey(entry.getKey());
+            SurrogateQueryRegistry.instance().registerSurrogateQueryForFeature(inputKey, entry.getValue());
+        }
+    }
+    
+    private Map<EStructuralFeature, PQueryProvider> getSurrogateQueryProviders() {
+        if(contributedSurrogateQueries != null) {
+            return contributedSurrogateQueries;
+        }
+        contributedSurrogateQueries = new HashMap<>();
+        if (Platform.isRunning()) {
+            for (IConfigurationElement e : Platform.getExtensionRegistry().getConfigurationElementsFor(ViatraQueryRuntimeConstants.SURROGATE_QUERY_EXTENSIONID)) {
+                if (e.isValid()) {
+                    processExtension(e);
+                }
+            }
+        }
+        return contributedSurrogateQueries;
+    }
+    private void processExtension(IConfigurationElement el) {
+        
+        try {
+            String packageUri = el.getAttribute("package-nsUri");
+            String className = el.getAttribute("class-name");
+            String featureName = el.getAttribute("feature-name");
+            String queryFqn = el.getAttribute("query-fqn");
+            if (queryFqn == null) {
+                queryFqn = "";
+            }
+            PQueryProvider surrogateQueryProvider = new PQueryProvider(el); 
+            
+            String contributorName = el.getContributor().getName();
+            StringBuilder featureIdBuilder = new StringBuilder();
+            checkState(packageUri != null, "Package NsURI cannot be null in extension");
+            checkState(className != null, "Class name cannot be null in extension");
+            checkState(featureName != null, "Feature name cannot be null in extension");
+            
+            EPackage pckg = EPackage.Registry.INSTANCE.getEPackage(packageUri);
+            featureIdBuilder.append(packageUri);
+            checkState(pckg != null, "Package %s not found! (plug-in %s)", packageUri, contributorName);
+            
+            EClassifier clsr = pckg.getEClassifier(className);
+            featureIdBuilder.append("##").append(className);
+            checkState(clsr instanceof EClass, "EClassifier %s does not exist in package %s! (plug-in %s)", className, packageUri, contributorName);
+            
+            EClass cls = (EClass) clsr;
+            EStructuralFeature feature = cls.getEStructuralFeature(featureName);
+            featureIdBuilder.append("##").append(featureName);
+            checkState(feature != null, "Feature %s of EClass %s in package %s not found! (plug-in %s)", featureName, className, packageUri, contributorName);
+            
+            PQueryProvider fqnInMap = contributedSurrogateQueries.get(feature);
+            if(fqnInMap != null) {
+                String duplicateSurrogateFormatString = DUPLICATE_SURROGATE_QUERY;
+                Collection<String> contributorPlugins = Arrays.asList(contributorName, contributingPluginOfFeatureMap.get(featureIdBuilder.toString()));
+                String duplicateSurrogateMessage = String.format(duplicateSurrogateFormatString, queryFqn, featureName,
+                        className, packageUri, fqnInMap, contributorPlugins, contributorName);
+                throw new IllegalStateException(duplicateSurrogateMessage);
+            }
+            contributedSurrogateQueries.put(feature, surrogateQueryProvider);
+            contributingPluginOfFeatureMap.put(featureIdBuilder.toString(), contributorName);
+        } catch (Exception e) {
+            final Logger logger = Logger.getLogger(SurrogateQueryRegistry.class);
+            logger.error("Surrogate query registration failed", e);
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/ExtensionBasedSystemDefaultBackendLoader.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/ExtensionBasedSystemDefaultBackendLoader.java
new file mode 100644
index 00000000..4339b70c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/ExtensionBasedSystemDefaultBackendLoader.java
@@ -0,0 +1,60 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Zoltan Ujhelyi, IncQuery Labs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.internal;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.Platform;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngineOptions;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendFactory;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendFactoryProvider;
+import tools.refinery.viatra.runtime.util.ViatraQueryLoggingUtil;
+/**
+ * @since 2.0
+ */
+public class ExtensionBasedSystemDefaultBackendLoader {
+    private static final String EXTENSION_ID = "tools.refinery.viatra.runtime.querybackend";
+    private static final ExtensionBasedSystemDefaultBackendLoader INSTANCE = new ExtensionBasedSystemDefaultBackendLoader();
+    
+    public static ExtensionBasedSystemDefaultBackendLoader instance() {
+        return INSTANCE;
+    }
+    public void loadKnownBackends() {
+        IQueryBackendFactory defaultBackend = null;
+        IQueryBackendFactory defaultCachingBackend = null;
+        IQueryBackendFactory defaultSearchBackend = null;
+        final IConfigurationElement[] config = Platform.getExtensionRegistry().getConfigurationElementsFor(EXTENSION_ID);
+        for (IConfigurationElement e : config) {
+            try {
+                IQueryBackendFactoryProvider provider = (IQueryBackendFactoryProvider) e
+                        .createExecutableExtension("provider");
+                if (provider.isSystemDefaultEngine()) {
+                    defaultBackend = provider.getFactory();
+                }
+                if (provider.isSystemDefaultCachingBackend()) {
+                    defaultCachingBackend = provider.getFactory();
+                }
+                if (provider.isSystemDefaultSearchBackend()) {
+                    defaultSearchBackend = provider.getFactory();
+                }
+                
+            } catch (CoreException ex) {
+                // In case errors try to continue with the next one
+                ViatraQueryLoggingUtil.getLogger(getClass()).error(
+                        String.format("Error while initializing backend %s from plugin %s.",
+                                e.getAttribute("backend"), e.getContributor().getName()), ex);
+            }
+        }
+        ViatraQueryEngineOptions.setSystemDefaultBackends(defaultBackend, defaultCachingBackend, defaultSearchBackend);
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/apiimpl/EngineContextFactory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/apiimpl/EngineContextFactory.java
new file mode 100644
index 00000000..bed07ebf
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/apiimpl/EngineContextFactory.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.internal.apiimpl;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.scope.IEngineContext;
+import tools.refinery.viatra.runtime.api.scope.IIndexingErrorListener;
+/**
+ * Internal interface for a Scope to reveal model contents to the engine.
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public abstract class EngineContextFactory {
+    protected abstract IEngineContext createEngineContext(ViatraQueryEngine engine, IIndexingErrorListener errorListener, Logger logger);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/apiimpl/QueryResultWrapper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/apiimpl/QueryResultWrapper.java
new file mode 100644
index 00000000..47f3268d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/apiimpl/QueryResultWrapper.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.internal.apiimpl;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+import tools.refinery.viatra.runtime.matchers.backend.IMatcherCapability;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+/**
+ * Internal class for wrapping a query result providing backend. It's only supported usage is by the
+ * {@link ViatraQueryEngineImpl} class.
+ * </p>
+ * 
+ * <strong>Important note</strong>: this class must not introduce any public method, as it will be visible through
+ * BaseMatcher as an API, although this class is not an API itself.
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public abstract class QueryResultWrapper {
+    protected IQueryResultProvider backend;
+    protected abstract void setBackend(ViatraQueryEngine engine, IQueryResultProvider resultProvider, IMatcherCapability capabilities);
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/apiimpl/ViatraQueryEngineImpl.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/apiimpl/ViatraQueryEngineImpl.java
new file mode 100644
index 00000000..c2341273
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/apiimpl/ViatraQueryEngineImpl.java
@@ -0,0 +1,705 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.internal.apiimpl;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.api.*;
+import tools.refinery.viatra.runtime.api.impl.BaseMatcher;
+import tools.refinery.viatra.runtime.api.scope.IBaseIndex;
+import tools.refinery.viatra.runtime.api.scope.IEngineContext;
+import tools.refinery.viatra.runtime.api.scope.IIndexingErrorListener;
+import tools.refinery.viatra.runtime.api.scope.QueryScope;
+import tools.refinery.viatra.runtime.exception.ViatraQueryException;
+import tools.refinery.viatra.runtime.internal.engine.LifecycleProvider;
+import tools.refinery.viatra.runtime.internal.engine.ModelUpdateProvider;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.backend.*;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.context.IQueryCacheContext;
+import tools.refinery.viatra.runtime.matchers.context.IQueryResultProviderAccess;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+import tools.refinery.viatra.runtime.matchers.psystem.analysis.QueryAnalyzer;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQueries;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery.PQueryStatus;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+import tools.refinery.viatra.runtime.registry.IDefaultRegistryView;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistry;
+import tools.refinery.viatra.runtime.registry.QuerySpecificationRegistry;
+import tools.refinery.viatra.runtime.util.ViatraQueryLoggingUtil;
+import java.lang.ref.WeakReference;
+import java.lang.reflect.InvocationTargetException;
+import java.util.*;
+import java.util.concurrent.Callable;
+import java.util.stream.Collectors;
+import static tools.refinery.viatra.runtime.matchers.util.Preconditions.checkArgument;
+/**
+ * A VIATRA Query engine back-end (implementation)
+ *
+ * @author Bergmann Gábor
+ */
+public final class ViatraQueryEngineImpl extends AdvancedViatraQueryEngine
+        implements IQueryBackendHintProvider, IQueryCacheContext, IQueryResultProviderAccess {
+    /**
+     *
+     */
+    private static final String ERROR_ACCESSING_BACKEND = "Error while accessing query evaluator backend";
+    /**
+     *
+     */
+    private static final String QUERY_ON_DISPOSED_ENGINE_MESSAGE = "Cannot evaluate query on disposed engine!";
+    /**
+     * The engine manager responsible for this engine. Null if this engine is unmanaged.
+     */
+    private final ViatraQueryEngineManager manager;
+    /**
+     * The model to which the engine is attached.
+     */
+    private final QueryScope scope;
+    /**
+     * The context of the engine, provided by the scope.
+     */
+    private IEngineContext engineContext;
+    /**
+     * Initialized matchers for each query
+     */
+    private final IMultiLookup<IQuerySpecification<? extends ViatraQueryMatcher<?>>, ViatraQueryMatcher<?>> matchers =
+            CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+    /**
+     * The RETE and other pattern matcher implementations of the VIATRA Query Engine.
+     */
+    private volatile Map<IQueryBackendFactory, IQueryBackend> queryBackends = new HashMap<>();
+    /**
+     * The current engine default hints
+     */
+    private final ViatraQueryEngineOptions engineOptions;
+    /**
+     * Common query analysis provided to backends
+     */
+    private QueryAnalyzer queryAnalyzer;
+    /**
+     * true if message delivery is currently delayed, false otherwise
+     */
+    private boolean delayMessageDelivery = true;
+    private final LifecycleProvider lifecycleProvider;
+    private final ModelUpdateProvider modelUpdateProvider;
+    private Logger logger;
+    private boolean disposed = false;
+    /**
+     * @param manager
+     *            null if unmanaged
+     * @param scope
+     * @param engineDefaultHint
+     * @since 1.4
+     */
+    public ViatraQueryEngineImpl(ViatraQueryEngineManager manager, QueryScope scope,
+            ViatraQueryEngineOptions engineOptions) {
+        super();
+        this.manager = manager;
+        this.scope = scope;
+        this.lifecycleProvider = new LifecycleProvider(this, getLogger());
+        this.modelUpdateProvider = new ModelUpdateProvider(this, getLogger());
+        this.engineContext = scope.createEngineContext(this, taintListener, getLogger());
+        if (engineOptions != null) {
+            this.engineOptions = engineOptions;
+        } else {
+            this.engineOptions = ViatraQueryEngineOptions.getDefault();
+        }
+    }
+    /**
+     * @param manager
+     *            null if unmanaged
+     * @param scope
+     * @param engineDefaultHint
+     */
+    public ViatraQueryEngineImpl(ViatraQueryEngineManager manager, QueryScope scope) {
+        this(manager, scope, ViatraQueryEngineOptions.getDefault());
+    }
+    @Override
+    public boolean isUpdatePropagationDelayed() {
+        return this.delayMessageDelivery;
+    }
+    @Override
+    public <V> V delayUpdatePropagation(Callable<V> callable) throws InvocationTargetException {
+                if (!delayMessageDelivery) {
+                        throw new IllegalStateException("Trying to delay propagation while changes are being flushed");
+                }
+        try {
+            return callable.call();
+        } catch (Exception e) {
+            throw new InvocationTargetException(e);
+        }
+    }
+        @Override
+        public void flushChanges() {
+                if (!delayMessageDelivery) {
+                        throw new IllegalStateException("Trying to flush changes while changes are already being flushed");
+                }
+                delayMessageDelivery = false;
+                try {
+                        for (IQueryBackend backend : this.queryBackends.values()) {
+                                backend.flushUpdates();
+                        }
+                } finally {
+                        delayMessageDelivery = true;
+                }
+        }
+        @Override
+    public Set<? extends ViatraQueryMatcher<? extends IPatternMatch>> getCurrentMatchers() {
+        return matchers.distinctValuesStream().collect(Collectors.toSet());
+    }
+    @Override
+    public <Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> Matcher getMatcher(
+            IQuerySpecification<Matcher> querySpecification) {
+        return getMatcher(querySpecification, null);
+    }
+    @Override
+    public <Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> Matcher getMatcher(
+            IQuerySpecification<Matcher> querySpecification, QueryEvaluationHint optionalEvaluationHints) {
+        IMatcherCapability capability = getRequestedCapability(querySpecification, optionalEvaluationHints);
+        Matcher matcher = doGetExistingMatcher(querySpecification, capability);
+        if (matcher != null) {
+            return matcher;
+        }
+        matcher = querySpecification.instantiate();
+        BaseMatcher<?> baseMatcher = (BaseMatcher<?>) matcher;
+        ((QueryResultWrapper) baseMatcher).setBackend(this,
+                getResultProvider(querySpecification, optionalEvaluationHints), capability);
+        internalRegisterMatcher(querySpecification, baseMatcher);
+        return matcher;
+    }
+    @Override
+    public <Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> Matcher getExistingMatcher(
+            IQuerySpecification<Matcher> querySpecification) {
+        return getExistingMatcher(querySpecification, null);
+    }
+    @Override
+    public <Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> Matcher getExistingMatcher(
+            IQuerySpecification<Matcher> querySpecification, QueryEvaluationHint optionalOverrideHints) {
+        return doGetExistingMatcher(querySpecification, getRequestedCapability(querySpecification, optionalOverrideHints));
+    }
+    @SuppressWarnings("unchecked")
+    private <Matcher extends ViatraQueryMatcher<? extends IPatternMatch>> Matcher doGetExistingMatcher(
+            IQuerySpecification<Matcher> querySpecification, IMatcherCapability requestedCapability) {
+        for (ViatraQueryMatcher<?> matcher : matchers.lookupOrEmpty(querySpecification)) {
+            BaseMatcher<?> baseMatcher = (BaseMatcher<?>) matcher;
+            if (baseMatcher.getCapabilities().canBeSubstitute(requestedCapability))
+                return (Matcher) matcher;
+        }
+        return null;
+    }
+    @Override
+    public ViatraQueryMatcher<? extends IPatternMatch> getMatcher(String patternFQN) {
+        IQuerySpecificationRegistry registry = QuerySpecificationRegistry.getInstance();
+        IDefaultRegistryView view = registry.getDefaultView();
+        IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification = view
+                .getEntry(patternFQN).get();
+        if (querySpecification != null) {
+            return getMatcher(querySpecification);
+        } else {
+            throw new ViatraQueryException(String.format(
+                    "No matcher could be constructed for the pattern with FQN %s; if the generated matcher class is not available, please access for the first time using getMatcher(IQuerySpecification)",
+                    patternFQN), "No matcher could be constructed for given pattern FQN.");
+        }
+    }
+    @Override
+    public IBaseIndex getBaseIndex() {
+        return engineContext.getBaseIndex();
+    }
+    public final Logger getLogger() {
+        if (logger == null) {
+            final int hash = System.identityHashCode(this);
+            logger = Logger.getLogger(ViatraQueryLoggingUtil.getLogger(ViatraQueryEngine.class).getName() + "." + hash);
+            if (logger == null)
+                throw new AssertionError(
+                        "Configuration error: unable to create VIATRA Query runtime logger for engine " + hash);
+        }
+        return logger;
+    }
+    ///////////////// internal stuff //////////////
+    private void internalRegisterMatcher(IQuerySpecification<?> querySpecification, ViatraQueryMatcher<?> matcher) {
+        matchers.addPair(querySpecification, matcher);
+        lifecycleProvider.matcherInstantiated(matcher);
+    }
+    /**
+     * Provides access to the selected query backend component of the VIATRA Query Engine.
+     */
+    @Override
+    public IQueryBackend getQueryBackend(IQueryBackendFactory iQueryBackendFactory) {
+        IQueryBackend iQueryBackend = queryBackends.get(iQueryBackendFactory);
+        if (iQueryBackend == null) {
+            // do this first, to make sure the runtime context exists
+            final IQueryRuntimeContext queryRuntimeContext = engineContext.getQueryRuntimeContext();
+            // maybe the backend has been created in the meantime when the indexer was initialized and queried for
+            // derived features
+            // no need to instantiate a new backend in that case
+            iQueryBackend = queryBackends.get(iQueryBackendFactory);
+            if (iQueryBackend == null) {
+                // need to instantiate the backend
+                iQueryBackend = iQueryBackendFactory.create(new IQueryBackendContext() {
+                    @Override
+                    public IQueryRuntimeContext getRuntimeContext() {
+                        return queryRuntimeContext;
+                    }
+                    @Override
+                    public IQueryCacheContext getQueryCacheContext() {
+                        return ViatraQueryEngineImpl.this;
+                    }
+                    @Override
+                    public Logger getLogger() {
+                        return logger;
+                    }
+                    @Override
+                    public IQueryBackendHintProvider getHintProvider() {
+                        return ViatraQueryEngineImpl.this;
+                    }
+                    @Override
+                    public IQueryResultProviderAccess getResultProviderAccess() {
+                        return ViatraQueryEngineImpl.this;
+                    }
+                    @Override
+                    public QueryAnalyzer getQueryAnalyzer() {
+                        if (queryAnalyzer == null)
+                            queryAnalyzer = new QueryAnalyzer(queryRuntimeContext.getMetaContext());
+                        return queryAnalyzer;
+                    }
+                    @Override
+                    public boolean areUpdatesDelayed() {
+                        return ViatraQueryEngineImpl.this.delayMessageDelivery;
+                    }
+                    @Override
+                    public IMatcherCapability getRequiredMatcherCapability(PQuery query,
+                            QueryEvaluationHint hint) {
+                        return engineOptions.getQueryBackendFactory(hint).calculateRequiredCapability(query, hint);
+                    }
+                });
+                queryBackends.put(iQueryBackendFactory, iQueryBackend);
+            }
+        }
+        return iQueryBackend;
+    }
+    ///////////////// advanced stuff /////////////
+    @Override
+    public void dispose() {
+        if (manager != null) {
+            throw new UnsupportedOperationException(
+                    String.format("Cannot dispose() managed VIATRA Query Engine. Attempted for scope %s.", scope));
+        }
+        wipe();
+        this.disposed = true;
+        // called before base index disposal to allow removal of base listeners
+        lifecycleProvider.engineDisposed();
+        try {
+            engineContext.dispose();
+        } catch (IllegalStateException ex) {
+            getLogger().warn(
+                    "The base index could not be disposed along with the VIATRA Query engine, as there are still active listeners on it.");
+        }
+    }
+    @Override
+    public void wipe() {
+        if (manager != null) {
+            throw new UnsupportedOperationException(
+                    String.format("Cannot wipe() managed VIATRA Query Engine. Attempted for scope %s.", scope));
+        }
+        if (queryBackends != null) {
+            for (IQueryBackend backend : queryBackends.values()) {
+                backend.dispose();
+            }
+            queryBackends.clear();
+        }
+        matchers.clear();
+        queryAnalyzer = null;
+        lifecycleProvider.engineWiped();
+    }
+    /**
+     * Indicates whether the engine is in a tainted, inconsistent state.
+     */
+    private boolean tainted = false;
+    private IIndexingErrorListener taintListener = new SelfTaintListener(this);
+    private static class SelfTaintListener implements IIndexingErrorListener {
+        WeakReference<ViatraQueryEngineImpl> queryEngineRef;
+        public SelfTaintListener(ViatraQueryEngineImpl queryEngine) {
+            this.queryEngineRef = new WeakReference<ViatraQueryEngineImpl>(queryEngine);
+        }
+        public void engineBecameTainted(String description, Throwable t) {
+            final ViatraQueryEngineImpl queryEngine = queryEngineRef.get();
+            if (queryEngine != null) {
+                queryEngine.tainted = true;
+                queryEngine.lifecycleProvider.engineBecameTainted(description, t);
+            }
+        }
+        private boolean noTaintDetectedYet = true;
+        protected void notifyTainted(String description, Throwable t) {
+            if (noTaintDetectedYet) {
+                noTaintDetectedYet = false;
+                engineBecameTainted(description, t);
+            }
+        }
+        @Override
+        public void error(String description, Throwable t) {
+            // Errors does not mean tainting
+        }
+        @Override
+        public void fatal(String description, Throwable t) {
+            notifyTainted(description, t);
+        }
+    }
+    @Override
+    public boolean isTainted() {
+        return tainted;
+    }
+    @Override
+    public boolean isManaged() {
+        return manager != null;
+        // return isAdvanced; ???
+    }
+    private <Match extends IPatternMatch> IQueryResultProvider getUnderlyingResultProvider(
+            final BaseMatcher<Match> matcher) {
+        // IQueryResultProvider resultProvider = reteEngine.accessMatcher(matcher.getSpecification());
+        return matcher.backend;
+    }
+    @Override
+    public <Match extends IPatternMatch> void addMatchUpdateListener(final ViatraQueryMatcher<Match> matcher,
+            final IMatchUpdateListener<? super Match> listener, boolean fireNow) {
+        checkArgument(listener != null, "Cannot add null listener!");
+        checkArgument(matcher.getEngine() == this, "Cannot register listener for matcher of different engine!");
+        checkArgument(!disposed, "Cannot register listener on matcher of disposed engine!");
+        final BaseMatcher<Match> bm = (BaseMatcher<Match>) matcher;
+        final IUpdateable updateDispatcher = (updateElement, isInsertion) -> {
+            Match match = null;
+            try {
+                match = bm.newMatch(updateElement.getElements());
+                if (isInsertion)
+                    listener.notifyAppearance(match);
+                else
+                    listener.notifyDisappearance(match);
+            } catch (Throwable e) { // NOPMD
+                if (e instanceof Error)
+                    throw (Error) e;
+                logger.warn(
+                        String.format(
+                                "The incremental pattern matcher encountered an error during %s a callback on %s of match %s of pattern %s. Error message: %s. (Developer note: %s in %s callback)",
+                                match == null ? "preparing" : "invoking", isInsertion ? "insertion" : "removal",
+                                match == null ? updateElement.toString() : match.prettyPrint(),
+                                matcher.getPatternName(), e.getMessage(), e.getClass().getSimpleName(), listener),
+                        e);
+            }
+        };
+        IQueryResultProvider resultProvider = getUnderlyingResultProvider(bm);
+        resultProvider.addUpdateListener(updateDispatcher, listener, fireNow);
+    }
+    @Override
+    public <Match extends IPatternMatch> void removeMatchUpdateListener(ViatraQueryMatcher<Match> matcher,
+            IMatchUpdateListener<? super Match> listener) {
+        checkArgument(listener != null, "Cannot remove null listener!");
+        checkArgument(matcher.getEngine() == this, "Cannot remove listener from matcher of different engine!");
+        checkArgument(!disposed, "Cannot remove listener from matcher of disposed engine!");
+        final BaseMatcher<Match> bm = (BaseMatcher<Match>) matcher;
+        try {
+            IQueryResultProvider resultProvider = getUnderlyingResultProvider(bm);
+            resultProvider.removeUpdateListener(listener);
+        } catch (Exception e) {
+            logger.error(
+                    "Error while removing listener " + listener + " from the matcher of " + matcher.getPatternName(),
+                    e);
+        }
+    }
+    @Override
+    public void addModelUpdateListener(ViatraQueryModelUpdateListener listener) {
+        modelUpdateProvider.addListener(listener);
+    }
+    @Override
+    public void removeModelUpdateListener(ViatraQueryModelUpdateListener listener) {
+        modelUpdateProvider.removeListener(listener);
+    }
+    @Override
+    public void addLifecycleListener(ViatraQueryEngineLifecycleListener listener) {
+        lifecycleProvider.addListener(listener);
+    }
+    @Override
+    public void removeLifecycleListener(ViatraQueryEngineLifecycleListener listener) {
+        lifecycleProvider.removeListener(listener);
+    }
+    /**
+     * Returns an internal interface towards the query backend to feed the matcher with results.
+     *
+     * @param query
+     *            the pattern for which the result provider should be delivered
+     *
+     * @throws ViatraQueryRuntimeException
+     */
+    public IQueryResultProvider getResultProvider(IQuerySpecification<?> query) {
+        Preconditions.checkState(!disposed, QUERY_ON_DISPOSED_ENGINE_MESSAGE);
+        return getResultProviderInternal(query, null);
+    }
+    /**
+     * Returns an internal interface towards the query backend to feed the matcher with results.
+     *
+     * @param query
+     *            the pattern for which the result provider should be delivered
+     *
+     * @throws ViatraQueryRuntimeException
+     */
+    public IQueryResultProvider getResultProvider(IQuerySpecification<?> query, QueryEvaluationHint hint) {
+        Preconditions.checkState(!disposed, QUERY_ON_DISPOSED_ENGINE_MESSAGE);
+        return getResultProviderInternal(query, hint);
+    }
+    /**
+     * This method returns the result provider exactly as described by the passed hint. Query cannot be null! Use
+     * {@link #getQueryEvaluationHint(IQuerySpecification, QueryEvaluationHint)} before passing a hint to this method to
+     * make sure engine and query specific hints are correctly applied.
+     *
+     * @throws ViatraQueryRuntimeException
+     */
+    private IQueryResultProvider getResultProviderInternal(IQuerySpecification<?> query, QueryEvaluationHint hint) {
+        return getResultProviderInternal(query.getInternalQueryRepresentation(), hint);
+    }
+    /**
+     * This method returns the result provider exactly as described by the passed hint. Query cannot be null! Use
+     * {@link #getQueryEvaluationHint(IQuerySpecification, QueryEvaluationHint)} before passing a hint to this method to
+     * make sure engine and query specific hints are correctly applied.
+     *
+     * @throws ViatraQueryRuntimeException
+     */
+    private IQueryResultProvider getResultProviderInternal(PQuery query, QueryEvaluationHint hint) {
+        Preconditions.checkArgument(query != null, "Query cannot be null!");
+        Preconditions.checkArgument(query.getStatus() != PQueryStatus.ERROR, "Cannot initialize a result provider for the erronoues query `%s`.", query.getSimpleName());
+        final IQueryBackend backend = getQueryBackend(engineOptions.getQueryBackendFactory(getQueryEvaluationHint(query, hint)));
+        return backend.getResultProvider(query, hint);
+    }
+    /**
+     * Returns the query backend (influenced by the hint system), even if it is a non-caching backend.
+     *
+     * @throws ViatraQueryRuntimeException
+     */
+    private IQueryBackend getQueryBackend(PQuery query) {
+        final IQueryBackendFactory factory = engineOptions.getQueryBackendFactory(getQueryEvaluationHint(query));
+        return getQueryBackend(factory);
+    }
+    /**
+     * Returns a caching query backend (influenced by the hint system).
+     *
+     * @throws ViatraQueryRuntimeException
+     */
+    private IQueryBackend getCachingQueryBackend(PQuery query) {
+        IQueryBackend regularBackend = getQueryBackend(query);
+        if (regularBackend.isCaching())
+            return regularBackend;
+        else
+            return getQueryBackend(engineOptions.getDefaultCachingBackendFactory());
+    }
+    @Override
+    public boolean isResultCached(PQuery query) {
+        try {
+            return null != getCachingQueryBackend(query).peekExistingResultProvider(query);
+        } catch (ViatraQueryException iqe) {
+            getLogger().error(ERROR_ACCESSING_BACKEND, iqe);
+            return false;
+        }
+    }
+    @Override
+    public IQueryResultProvider getCachingResultProvider(PQuery query) {
+        try {
+            return getCachingQueryBackend(query).getResultProvider(query);
+        } catch (ViatraQueryException iqe) {
+            getLogger().error(ERROR_ACCESSING_BACKEND, iqe);
+            throw iqe;
+        }
+    }
+    private QueryEvaluationHint getEngineDefaultHint() {
+        return engineOptions.getEngineDefaultHints();
+    }
+    @Override
+    public QueryEvaluationHint getQueryEvaluationHint(PQuery query) {
+        return getEngineDefaultHint().overrideBy(query.getEvaluationHints());
+    }
+    private QueryEvaluationHint getQueryEvaluationHint(IQuerySpecification<?> querySpecification,
+            QueryEvaluationHint optionalOverrideHints) {
+        return getQueryEvaluationHint(querySpecification.getInternalQueryRepresentation())
+                        .overrideBy(optionalOverrideHints);
+    }
+    private QueryEvaluationHint getQueryEvaluationHint(PQuery query, QueryEvaluationHint optionalOverrideHints) {
+        return getQueryEvaluationHint(query).overrideBy(optionalOverrideHints);
+    }
+    private IMatcherCapability getRequestedCapability(IQuerySpecification<?> querySpecification,
+            QueryEvaluationHint optionalOverrideHints) {
+        final QueryEvaluationHint hint = getQueryEvaluationHint(querySpecification, optionalOverrideHints);
+        return engineOptions.getQueryBackendFactory(hint)
+                .calculateRequiredCapability(querySpecification.getInternalQueryRepresentation(), hint);
+    }
+    @Override
+    public void prepareGroup(IQueryGroup queryGroup, final QueryEvaluationHint optionalEvaluationHints) {
+        try {
+            Preconditions.checkState(!disposed, QUERY_ON_DISPOSED_ENGINE_MESSAGE);
+            final Set<IQuerySpecification<?>> specifications = new HashSet<IQuerySpecification<?>>(
+                    queryGroup.getSpecifications());
+            final Collection<PQuery> patterns = specifications.stream().map(
+                    IQuerySpecification::getInternalQueryRepresentation).collect(Collectors.toList());
+            patterns.forEach(PQuery::ensureInitialized);
+            Collection<String> erroneousPatterns = patterns.stream().
+                    filter(PQueries.queryStatusPredicate(PQueryStatus.ERROR)).
+                    map(PQuery::getFullyQualifiedName).
+                    collect(Collectors.toList());
+            Preconditions.checkState(erroneousPatterns.isEmpty(), "Erroneous query(s) found: %s",
+                    erroneousPatterns.stream().collect(Collectors.joining(", ")));
+            // TODO maybe do some smarter preparation per backend?
+            try {
+                engineContext.getBaseIndex().coalesceTraversals(new Callable<Void>() {
+                    @Override
+                    public Void call() throws Exception {
+                        for (IQuerySpecification<?> query : specifications) {
+                            getResultProviderInternal(query, optionalEvaluationHints);
+                        }
+                        return null;
+                    }
+                });
+            } catch (InvocationTargetException ex) {
+                final Throwable cause = ex.getCause();
+                if (cause instanceof QueryProcessingException)
+                    throw (QueryProcessingException) cause;
+                if (cause instanceof ViatraQueryException)
+                    throw (ViatraQueryException) cause;
+                if (cause instanceof RuntimeException)
+                    throw (RuntimeException) cause;
+                assert (false);
+            }
+        } catch (QueryProcessingException e) {
+            throw new ViatraQueryException(e);
+        }
+    }
+    @Override
+    public QueryScope getScope() {
+        return scope;
+    }
+    @Override
+    public ViatraQueryEngineOptions getEngineOptions() {
+        return engineOptions;
+    }
+    @Override
+    public IQueryResultProvider getResultProviderOfMatcher(ViatraQueryMatcher<? extends IPatternMatch> matcher) {
+        return ((QueryResultWrapper) matcher).backend;
+    }
+    @Override
+    public IQueryResultProvider getResultProvider(PQuery query, QueryEvaluationHint overrideHints) {
+        try {
+            return getResultProviderInternal(query, overrideHints);
+        } catch (ViatraQueryException e) {
+            getLogger().error(ERROR_ACCESSING_BACKEND, e);
+            throw e;
+        }
+    }
+    @Override
+    public boolean isDisposed() {
+        return disposed;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/engine/LifecycleProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/engine/LifecycleProvider.java
new file mode 100644
index 00000000..8bbf2a66
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/engine/LifecycleProvider.java
@@ -0,0 +1,138 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.internal.engine;
+import java.util.ArrayList;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.api.AdvancedViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.IPatternMatch;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngineLifecycleListener;
+import tools.refinery.viatra.runtime.api.ViatraQueryMatcher;
+public final class LifecycleProvider extends ListenerContainer<ViatraQueryEngineLifecycleListener> implements ViatraQueryEngineLifecycleListener{
+        private final Logger logger;
+        /**
+         * @param queryEngine
+         */
+        public LifecycleProvider(AdvancedViatraQueryEngine queryEngine, Logger logger) {
+            this.logger = logger;
+        }
+        @Override
+        protected void listenerAdded(ViatraQueryEngineLifecycleListener listener) {
+            logger.debug("Lifecycle listener " + listener + " added to engine.");
+        }
+        @Override
+        protected void listenerRemoved(ViatraQueryEngineLifecycleListener listener) {
+            logger.debug("Lifecycle listener " + listener + " removed from engine.");
+        }
+//        public void propagateEventToListeners(Predicate<ViatraQueryEngineLifecycleListener> function) {
+//            if (!listeners.isEmpty()) {
+//                for (ViatraQueryEngineLifecycleListener listener : new ArrayList<ViatraQueryEngineLifecycleListener>(listeners)) {
+//                    try {
+//                        function.apply(listener);
+//                    } catch (Exception ex) {
+//                        logger.error(
+//                                "VIATRA Query encountered an error in delivering notification to listener "
+//                                        + listener + ".", ex);
+//                    }
+//                }
+//            }
+//        }
+        
+        @Override
+        public void matcherInstantiated(final ViatraQueryMatcher<? extends IPatternMatch> matcher) {
+            if (!listeners.isEmpty()) {
+                for (ViatraQueryEngineLifecycleListener listener : new ArrayList<ViatraQueryEngineLifecycleListener>(listeners)) {
+                    try {
+                        listener.matcherInstantiated(matcher);
+                    } catch (Exception ex) {
+                        logger.error(
+                                "VIATRA Query encountered an error in delivering matcher initialization notification to listener "
+                                        + listener + ".", ex);
+                    }
+                }
+            }
+//            propagateEventToListeners(new Predicate<ViatraQueryEngineLifecycleListener>() {
+//               public boolean apply(ViatraQueryEngineLifecycleListener listener) {
+//                   listener.matcherInstantiated(matcher);
+//                   return true;
+//               }
+//            });
+        }
+        @Override
+        public void engineBecameTainted(String description, Throwable t) {
+            if (!listeners.isEmpty()) {
+                for (ViatraQueryEngineLifecycleListener listener : new ArrayList<ViatraQueryEngineLifecycleListener>(listeners)) {
+                    try {
+                        listener.engineBecameTainted(description, t);
+                    } catch (Exception ex) {
+                        logger.error(
+                                "VIATRA Query encountered an error in delivering engine tainted notification to listener "
+                                        + listener + ".", ex);
+                    }
+                }
+            }
+//            propagateEventToListeners(new Predicate<ViatraQueryEngineLifecycleListener>() {
+//                public boolean apply(ViatraQueryEngineLifecycleListener listener) {
+//                    listener.engineBecameTainted();
+//                    return true;
+//                }
+//             });
+        }
+        @Override
+        public void engineWiped() {
+            if (!listeners.isEmpty()) {
+                for (ViatraQueryEngineLifecycleListener listener : new ArrayList<ViatraQueryEngineLifecycleListener>(listeners)) {
+                    try {
+                        listener.engineWiped();
+                    } catch (Exception ex) {
+                        logger.error(
+                                "VIATRA Query encountered an error in delivering engine wiped notification to listener "
+                                        + listener + ".", ex);
+                    }
+                }
+            }
+//            propagateEventToListeners(new Predicate<ViatraQueryEngineLifecycleListener>() {
+//                public boolean apply(ViatraQueryEngineLifecycleListener listener) {
+//                    listener.engineWiped();
+//                    return true;
+//                }
+//             });
+        }
+        @Override
+        public void engineDisposed() {
+            if (!listeners.isEmpty()) {
+                for (ViatraQueryEngineLifecycleListener listener : new ArrayList<ViatraQueryEngineLifecycleListener>(listeners)) {
+                    try {
+                        listener.engineDisposed();
+                    } catch (Exception ex) {
+                        logger.error(
+                                "VIATRA Query encountered an error in delivering engine disposed notification to listener "
+                                        + listener + ".", ex);
+                    }
+                }
+            }
+//            propagateEventToListeners(new Predicate<ViatraQueryEngineLifecycleListener>() {
+//                public boolean apply(ViatraQueryEngineLifecycleListener listener) {
+//                    listener.engineDisposed();
+//                    return true;
+//                }
+//             });
+        }
+        
+    }
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/engine/ListenerContainer.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/engine/ListenerContainer.java
new file mode 100644
index 00000000..34133bed
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/engine/ListenerContainer.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.internal.engine;
+import static tools.refinery.viatra.runtime.matchers.util.Preconditions.checkArgument;
+import java.util.HashSet;
+import java.util.Set;
+public abstract class ListenerContainer<Listener> {
+    
+    protected final Set<Listener> listeners;
+    
+    public ListenerContainer() {
+        this.listeners = new HashSet<Listener>();
+    }
+    
+    public synchronized void addListener(Listener listener) {
+        checkArgument(listener != null, "Cannot add null listener!");
+        boolean added = listeners.add(listener);
+        if(added) {
+            listenerAdded(listener);
+        }
+    }
+    
+    public synchronized void removeListener(Listener listener) {
+        checkArgument(listener != null, "Cannot remove null listener!");
+        boolean removed = listeners.remove(listener);
+        if(removed) {
+            listenerRemoved(listener);
+        }
+    }
+    
+    protected abstract void listenerAdded(Listener listener);
+    
+    protected abstract void listenerRemoved(Listener listener);
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/engine/ModelUpdateProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/engine/ModelUpdateProvider.java
new file mode 100644
index 00000000..1f2c27e8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/internal/engine/ModelUpdateProvider.java
@@ -0,0 +1,214 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.internal.engine;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.api.AdvancedViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.IMatchUpdateListener;
+import tools.refinery.viatra.runtime.api.IPatternMatch;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngineLifecycleListener;
+import tools.refinery.viatra.runtime.api.ViatraQueryMatcher;
+import tools.refinery.viatra.runtime.api.ViatraQueryModelUpdateListener;
+import tools.refinery.viatra.runtime.api.ViatraQueryModelUpdateListener.ChangeLevel;
+import tools.refinery.viatra.runtime.api.scope.ViatraBaseIndexChangeListener;
+import tools.refinery.viatra.runtime.exception.ViatraQueryException;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+public final class ModelUpdateProvider extends ListenerContainer<ViatraQueryModelUpdateListener> {
+    private final AdvancedViatraQueryEngine queryEngine;
+    private ChangeLevel currentChange = ChangeLevel.NO_CHANGE;
+    private ChangeLevel maxLevel = ChangeLevel.NO_CHANGE;
+    private final Map<ChangeLevel, Collection<ViatraQueryModelUpdateListener>> listenerMap;
+    private final Logger logger;
+    
+    public ModelUpdateProvider(AdvancedViatraQueryEngine queryEngine, Logger logger) {
+        super();
+        this.queryEngine = queryEngine;
+        this.logger = logger;
+        listenerMap = new EnumMap<>(ChangeLevel.class);
+    }
+    
+    @Override
+    protected void listenerAdded(ViatraQueryModelUpdateListener listener) {
+        // check ChangeLevel
+        // create callback for given level if required
+        if(listenerMap.isEmpty()) {
+            try {
+                this.queryEngine.getBaseIndex().addBaseIndexChangeListener(indexListener);
+                // add listener to new matchers (use lifecycle listener)
+                this.queryEngine.addLifecycleListener(selfListener);
+            } catch (ViatraQueryException e) {
+                throw new IllegalStateException("Model update listener used on engine without base index", e);
+            }
+        }
+        
+        ChangeLevel changeLevel = listener.getLevel();
+        listenerMap.computeIfAbsent(changeLevel, k -> CollectionsFactory.createSet()).add(listener);
+        // increase or keep max level of listeners
+        ChangeLevel oldMaxLevel = maxLevel;
+        maxLevel = maxLevel.changeOccured(changeLevel); 
+        if(!maxLevel.equals(oldMaxLevel) && ChangeLevel.MATCHSET.compareTo(oldMaxLevel) > 0 && ChangeLevel.MATCHSET.compareTo(maxLevel) <= 0) {
+            // add matchUpdateListener to all matchers
+            for (ViatraQueryMatcher<?> matcher : this.queryEngine.getCurrentMatchers()) {
+                this.queryEngine.addMatchUpdateListener(matcher, matchSetListener, false);
+            }
+        }
+    }
+    @Override
+    protected void listenerRemoved(ViatraQueryModelUpdateListener listener) {
+        ChangeLevel changeLevel = listener.getLevel();
+        Collection<ViatraQueryModelUpdateListener> old = listenerMap.getOrDefault(changeLevel, Collections.emptySet());
+        boolean removed = old.remove(listener);
+        if(removed) {
+            if (old.isEmpty()) listenerMap.remove(changeLevel);
+        } else {
+            handleUnsuccesfulRemove(listener);
+        }
+        
+        updateMaxLevel();
+        
+        if(listenerMap.isEmpty()) {
+            this.queryEngine.removeLifecycleListener(selfListener);
+            removeBaseIndexChangeListener();
+        }
+    }
+    private void removeBaseIndexChangeListener() {
+        try {
+            this.queryEngine.getBaseIndex().removeBaseIndexChangeListener(indexListener);
+        } catch (ViatraQueryException e) {
+            throw new IllegalStateException("Model update listener used on engine without base index", e);
+        }
+    }
+    private void updateMaxLevel() {
+        if(!listenerMap.containsKey(maxLevel)) {
+            ChangeLevel newMaxLevel = ChangeLevel.NO_CHANGE;
+            for (ChangeLevel level : new HashSet<>(listenerMap.keySet())) {
+                newMaxLevel = newMaxLevel.changeOccured(level);
+            }
+            maxLevel = newMaxLevel;
+        }
+        if(maxLevel.compareTo(ChangeLevel.MATCHSET) < 0) {
+            // remove listener from matchers
+            for (ViatraQueryMatcher<?> matcher : this.queryEngine.getCurrentMatchers()) {
+                this.queryEngine.removeMatchUpdateListener(matcher, matchSetListener);
+            }
+        }
+    }
+    private void handleUnsuccesfulRemove(ViatraQueryModelUpdateListener listener) {
+        for (Entry<ChangeLevel, Collection<ViatraQueryModelUpdateListener>> entry : listenerMap.entrySet()) {
+            Collection<ViatraQueryModelUpdateListener> existingListeners = entry.getValue();
+            // if the listener is contained in some other bucket, remove it from there
+            if(existingListeners.remove(listener)) {
+                logger.error("Listener "+listener+" change level changed since initialization!");
+                if (existingListeners.isEmpty()) listenerMap.remove(entry.getKey());
+                return; // listener is contained only once
+            }
+        }
+        logger.error("Listener "+listener+" already removed from map (e.g. engine was already disposed)!");
+    }
+    private void notifyListeners() {
+        
+        // any change that occurs after this point should be regarded as a new event
+        // FIXME what should happen when a listener creates new notifications?
+        // -> other listeners will get events in different order
+        ChangeLevel tempLevel = currentChange;
+        currentChange = ChangeLevel.NO_CHANGE;
+        
+        if(!listenerMap.isEmpty()) {
+            for (ChangeLevel level : new HashSet<>(listenerMap.keySet())) {
+                if(tempLevel.compareTo(level) >= 0) {
+                    for (ViatraQueryModelUpdateListener listener : new ArrayList<>(listenerMap.get(level))) {
+                        try {
+                            listener.notifyChanged(tempLevel);
+                        } catch (Exception ex) {
+                            logger.error(
+                                    "VIATRA Query encountered an error in delivering model update notification to listener "
+                                            + listener + ".", ex);
+                        }
+                    }
+                }
+            }
+        } else {
+            throw new IllegalStateException("Notify listeners must not be called without listeners! Maybe an update callback was not removed correctly.");
+        }
+        
+    }
+    
+    // model update "providers":
+    // - model: IQBase callback even if not dirty
+    // - index: IQBase dirty callback
+    private final ViatraBaseIndexChangeListener indexListener = new ViatraBaseIndexChangeListener() {
+        
+        @Override
+        public boolean onlyOnIndexChange() {
+            return false;
+        }
+        
+        @Override
+        public void notifyChanged(boolean indexChanged) {
+            if(indexChanged) {
+                currentChange = currentChange.changeOccured(ChangeLevel.INDEX);
+            } else {
+                currentChange = currentChange.changeOccured(ChangeLevel.MODEL);
+            }
+            notifyListeners();
+        }
+        
+    };
+    // - matchset: add the same listener to each matcher and use a dirty flag. needs IQBase callback as well
+    private final IMatchUpdateListener<IPatternMatch> matchSetListener = new IMatchUpdateListener<IPatternMatch>() {
+        
+        @Override
+        public void notifyDisappearance(IPatternMatch match) {
+            currentChange = currentChange.changeOccured(ChangeLevel.MATCHSET);
+        }
+        
+        @Override
+        public void notifyAppearance(IPatternMatch match) {
+            currentChange = currentChange.changeOccured(ChangeLevel.MATCHSET);
+        }
+    };
+    
+    private final ViatraQueryEngineLifecycleListener selfListener = new ViatraQueryEngineLifecycleListener() {
+        
+        @Override
+        public void matcherInstantiated(ViatraQueryMatcher<? extends IPatternMatch> matcher) {
+            if (maxLevel.compareTo(ChangeLevel.MATCHSET) >= 0) {
+                ModelUpdateProvider.this.queryEngine.addMatchUpdateListener(matcher, matchSetListener, false);
+            }
+        }
+        
+        @Override
+        public void engineWiped() {}
+        
+        @Override
+        public void engineDisposed() {
+            removeBaseIndexChangeListener();
+            listenerMap.clear();
+            maxLevel = ChangeLevel.NO_CHANGE;
+        }
+        
+        @Override
+        public void engineBecameTainted(String description, Throwable t) {}
+    };
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/ExtensionBasedQuerySpecificationLoader.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/ExtensionBasedQuerySpecificationLoader.java
new file mode 100644
index 00000000..40bf3e67
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/ExtensionBasedQuerySpecificationLoader.java
@@ -0,0 +1,303 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.Platform;
+import tools.refinery.viatra.runtime.IExtensions;
+import tools.refinery.viatra.runtime.api.IQueryGroup;
+import tools.refinery.viatra.runtime.api.IQuerySpecification;
+import tools.refinery.viatra.runtime.extensibility.IQueryGroupProvider;
+import tools.refinery.viatra.runtime.extensibility.IQuerySpecificationProvider;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup;
+import tools.refinery.viatra.runtime.util.ViatraQueryLoggingUtil;
+/**
+ * Loader for the {@link QuerySpecificationRegistry} based on the query group extensions generated by the VIATRA Query
+ * builder. The loader has a single instance that processes the extensions on demand if the platform is running, caches
+ * the results and updates the {@link QuerySpecificationRegistry}. Note that the loader does not perform class loading
+ * on the query group if possible.
+ * 
+ * <p>
+ * The class has a single instance accessible with {@link #getInstance()}.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public class ExtensionBasedQuerySpecificationLoader {
+    public static final String CONNECTOR_ID = "tools.refinery.viatra.runtime.querygroup.extension.based.connector";
+    private static final String DUPLICATE_QUERY_GROUP_MESSAGE = "Duplicate query group identifier %s for plugin %s (already contributed by %s)";
+    private static final ExtensionBasedQuerySpecificationLoader INSTANCE = new ExtensionBasedQuerySpecificationLoader();
+    
+    private IMultiLookup<String, String> contributingPluginOfGroupMap = 
+            CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+    private Map<String, QueryGroupProvider> contributedQueryGroups;
+    private ExtensionBasedSourceConnector sourceConnector;
+    
+    /**
+     * @return the single instance of the loader.
+     */
+    public static ExtensionBasedQuerySpecificationLoader getInstance() {
+        return INSTANCE;
+    }
+    
+    /**
+     * Loads the query specifications that are registered through extension points into the
+     * {@link QuerySpecificationRegistry}.
+     */
+    public void loadRegisteredQuerySpecificationsIntoRegistry() {
+        ((QuerySpecificationRegistry) QuerySpecificationRegistry.getInstance()).addDelayedSourceConnector(getSourceConnector());
+    }
+    
+    /**
+     * Return a source connector that can be used to load query specifications contributed through
+     * extensions into a {@link IQuerySpecificationRegistry}.
+     * 
+     * @return the source connector
+     */
+    public IRegistrySourceConnector getSourceConnector() {
+        if (this.sourceConnector == null) {
+            this.sourceConnector = new ExtensionBasedSourceConnector();
+        }
+        return sourceConnector; 
+    }
+    private Map<String, QueryGroupProvider> getRegisteredQueryGroups() {
+        if(contributedQueryGroups != null) {
+            return contributedQueryGroups;
+        }
+        contributedQueryGroups = new HashMap<>();
+        if (Platform.isRunning()) {
+            for (IConfigurationElement e : Platform.getExtensionRegistry().getConfigurationElementsFor(IExtensions.QUERY_SPECIFICATION_EXTENSION_POINT_ID)) {
+                if (e.isValid()) {
+                    processExtension(e);
+                }
+            }
+        }
+        return contributedQueryGroups;
+    }
+    
+    private void processExtension(IConfigurationElement el) {
+        String id = null;
+        try {
+            String contributorName = el.getContributor().getName();
+            id = el.getAttribute("id");
+            if(id == null) {
+                throw new IllegalStateException(String.format("Query group extension identifier is required (plug-in: %s)!", contributorName));
+            }
+            
+            QueryGroupProvider provider = new QueryGroupProvider(el);
+            
+            QueryGroupProvider queryGroupInMap = contributedQueryGroups.get(id);
+            if(queryGroupInMap != null) {
+                IMemoryView<String> contributorPlugins = contributingPluginOfGroupMap.lookupOrEmpty(id);
+                throw new IllegalStateException(String.format(DUPLICATE_QUERY_GROUP_MESSAGE, id, contributorName, contributorPlugins.distinctValues()));
+            }
+            
+            contributedQueryGroups.put(id, provider);
+            contributingPluginOfGroupMap.addPair(id, contributorName);
+        } catch (Exception e) {
+            // If there are serious compilation errors in the file loaded by the query registry, an error is thrown
+            if (id == null) {
+                id = "undefined in plugin.xml";
+            }
+            ViatraQueryLoggingUtil.getLogger(ExtensionBasedQuerySpecificationLoader.class).error(
+                    "[ExtensionBasedQuerySpecificationLoader] Exception during query specification registry initialization when preparing group: "
+                            + id + "! " + e.getMessage(), e);
+        }
+    }
+    /**
+     * @author Abel Hegedus
+     *
+     */
+    private final class ExtensionBasedSourceConnector implements IRegistrySourceConnector {
+        
+        private Set<IConnectorListener> listeners;
+        
+        public ExtensionBasedSourceConnector() {
+            this.listeners = new HashSet<>();
+        }
+        
+        @Override
+        public String getIdentifier() {
+            return ExtensionBasedQuerySpecificationLoader.CONNECTOR_ID;
+        }
+        @Override
+        public void addListener(IConnectorListener listener) {
+            Objects.requireNonNull(listener, "Listener must not be null!");
+            boolean added = listeners.add(listener);
+            if(added) {
+                for (QueryGroupProvider queryGroupProvider : getRegisteredQueryGroups().values()) {
+                    for (IQuerySpecificationProvider specificationProvider : queryGroupProvider.getQuerySpecificationProviders()) {
+                        listener.querySpecificationAdded(this, specificationProvider);
+                    }
+                }
+            }
+        }
+        @Override
+        public void removeListener(IConnectorListener listener) {
+            Objects.requireNonNull(listener, "Listener must not be null!");
+            listeners.remove(listener);
+        }
+        @Override
+        public boolean includeSpecificationsInDefaultViews() {
+            return true;
+        }
+    }
+    /**
+     * Provider implementation that uses the group extension to load the query group on-demand.
+     * It also provides the set of query FQNs that are part of the group without class loading.
+     * Once loaded, the query group is cached for future use.
+     * 
+     * @author Abel Hegedus
+     */
+    private static final class QueryGroupProvider implements IQueryGroupProvider {
+    
+        private static final String DUPLICATE_FQN_MESSAGE = "Duplicate FQN %s in query group extension point (plug-in %s)";
+        private final IConfigurationElement element;
+        private IQueryGroup queryGroup;
+        private Set<String> querySpecificationFQNs;
+        private Map<String, IQuerySpecificationProvider> querySpecificationMap;
+        
+        public QueryGroupProvider(IConfigurationElement element) {
+            this.element = element;
+            this.queryGroup = null;
+            this.querySpecificationFQNs = null;
+            this.querySpecificationMap = null;
+        }
+        
+        @Override
+        public IQueryGroup get() {
+            try{
+                if(queryGroup == null) {
+                    queryGroup = (IQueryGroup) element.createExecutableExtension("group");
+                }
+                return queryGroup;
+            } catch (CoreException e) {
+                throw new IllegalStateException(e.getMessage(), e);
+            }
+        }
+        
+        @Override
+        public Set<String> getQuerySpecificationFQNs() {
+            if(querySpecificationFQNs == null) {
+                Set<String> fqns = new HashSet<>();
+                for (IConfigurationElement e : element.getChildren("query-specification")) {
+                    if (e.isValid()) {
+                        String fqn = e.getAttribute("fqn");
+                        boolean added = fqns.add(fqn);
+                        if(!added) {
+                            String contributorName = e.getContributor().getName();
+                            throw new IllegalArgumentException(String.format(DUPLICATE_FQN_MESSAGE,fqn, contributorName));
+                        }
+                    }
+                }
+                if(fqns.isEmpty()) {
+                    // we must load the class and get the specifications
+                    IQueryGroup loadedQueryGroup = get();
+                    for (IQuerySpecification<?> specification : loadedQueryGroup.getSpecifications()) {
+                        String fullyQualifiedName = specification.getFullyQualifiedName();
+                        boolean added = fqns.add(fullyQualifiedName);
+                        if(!added) {
+                            String contributorName = element.getContributor().getName();
+                            throw new IllegalArgumentException(String.format(DUPLICATE_FQN_MESSAGE, fullyQualifiedName, contributorName));
+                        }
+                    }
+                }
+                // we will never change the set after initialization
+                querySpecificationFQNs = new HashSet<>(fqns);
+            }
+            return querySpecificationFQNs;
+        }
+        
+        @Override
+        public Set<IQuerySpecificationProvider> getQuerySpecificationProviders() {
+            return new HashSet<>(getQuerySpecificationMap().values());
+        }
+        private Map<String, IQuerySpecificationProvider> getQuerySpecificationMap() {
+            if(querySpecificationMap == null){
+                querySpecificationMap = new HashMap<>();
+                Set<String> fqns = getQuerySpecificationFQNs();
+                for (String fqn : fqns) {
+                    querySpecificationMap.put(fqn, new GroupBasedQuerySpecificationProvider(fqn, this));
+                }
+            }
+            return querySpecificationMap;
+        }
+    }
+    
+    /**
+     * Provider implementation that uses the query group extension to load a query specification by its FQN. Note that
+     * the FQN of the provided query specification is set with the constructor and can be requested without loading the
+     * class. Once loaded, the query specification is cached for future use.
+     * 
+     * @author Abel Hegedus
+     *
+     */
+    private static final class GroupBasedQuerySpecificationProvider implements IQuerySpecificationProvider {
+        private String queryFQN;
+        private QueryGroupProvider queryGroupProvider;
+        private IQuerySpecification<?> specification;
+        public GroupBasedQuerySpecificationProvider(String queryFQN, QueryGroupProvider queryGroupProvider) {
+            this.queryFQN = queryFQN;
+            this.queryGroupProvider = queryGroupProvider;
+            this.specification = null;
+        }
+        
+        @Override
+        public IQuerySpecification<?> get() {
+            if(specification == null) {
+                if(queryGroupProvider.getQuerySpecificationFQNs().contains(queryFQN)) {
+                    for (IQuerySpecification<?> spec : queryGroupProvider.get().getSpecifications()) {
+                        if(spec.getFullyQualifiedName().equals(queryFQN)){
+                            this.specification = spec;
+                        }
+                    }
+                } else {
+                    throw new IllegalStateException(String.format("Could not find query specifition %s in group (plug-in %s)", queryFQN, queryGroupProvider.element.getContributor().getName()));
+                }
+            }
+            return specification;
+        }
+        @Override
+        public String getFullyQualifiedName() {
+            return queryFQN;
+        }
+        
+        @Override
+        public String getSourceProjectName() {
+            return queryGroupProvider.element.getContributor().getName();
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IConnectorListener.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IConnectorListener.java
new file mode 100644
index 00000000..318415cc
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IConnectorListener.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry;
+import tools.refinery.viatra.runtime.extensibility.IQuerySpecificationProvider;
+/**
+ * Connector listeners are used to receive notifications on addition and removal of query specifications.
+ * The connector itself is also passed in the methods to allow the usage of the same listener on multiple connectors.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public interface IConnectorListener {
+    /**
+     * Called when a new query specification is added to the given connector.
+     * The provider interface is used to avoid class loading as long as possible.
+     * 
+     * @param connector that has a new specification
+     * @param specificationProvider that wraps the new specification
+     */
+    void querySpecificationAdded(IRegistrySourceConnector connector, IQuerySpecificationProvider specificationProvider);
+    
+    /**
+     * Called when a query specification is removed from the given connector.
+     * The provider interface is used to avoid class loading as long as possible.
+     * 
+     * @param connector that has a removed specification
+     * @param specificationProvider that wraps the removed specification
+     */
+    void querySpecificationRemoved(IRegistrySourceConnector connector, IQuerySpecificationProvider specificationProvider);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IDefaultRegistryView.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IDefaultRegistryView.java
new file mode 100644
index 00000000..9e3e0394
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IDefaultRegistryView.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry;
+import java.util.NoSuchElementException;
+import tools.refinery.viatra.runtime.api.IQueryGroup;
+/**
+ * The default registry view ensures that the fully qualified name of entries are unique and provides an additional
+ * method for retrieving the query group of entries for easy initialization.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public interface IDefaultRegistryView extends IRegistryView {
+    /**
+     * @return a query group containing all query specifications
+     */
+    IQueryGroup getQueryGroup();
+    
+    /**
+     * @param fullyQualifiedName
+     *            of the entry that is requested
+     * @return the entry with the given FQN
+     * @throws NoSuchElementException if there is no such entry in the default view
+     */
+    IQuerySpecificationRegistryEntry getEntry(String fullyQualifiedName);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IQuerySpecificationRegistry.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IQuerySpecificationRegistry.java
new file mode 100644
index 00000000..97a17f0e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IQuerySpecificationRegistry.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry;
+/**
+ * The query specification registry is used to manage query specifications provided by multiple connectors which can
+ * dynamically add and remove specifications. Users can read the contents of the registry through views that are also
+ * dynamically updated when the registry is changed by the connectors.  
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public interface IQuerySpecificationRegistry {
+    /**
+     * Cannot register connectors with the same identifier twice. No change occurs if the identifier is already used.
+     * 
+     * @param connector
+     *            cannot be null
+     * @return false if a connector with the given identifier has already been added, true otherwise
+     */
+    boolean addSource(IRegistrySourceConnector connector);
+    /**
+     * Removes the connector if it was registered. No change occurs if the identifier of the connector was not used
+     * before.
+     * 
+     * @param connector
+     *            cannot be null
+     * @return false if a registered connector with the given identifier was not found, true if it was successfully
+     *         removed
+     */
+    boolean removeSource(IRegistrySourceConnector connector);
+    /**
+     * Returns a default view instance that contains query specification entries that indicate their inclusion in
+     * default views. If there are entries with the same FQN, only the last added will be included in the view to avoid
+     * duplicate FQNs.
+     * 
+     * @return the default view instance
+     */
+    IDefaultRegistryView getDefaultView();
+    
+    /**
+     * Creates a view which contains query specification entries that indicate their inclusion in default views. This
+     * view will also be incrementally updated on registry changes and accepts listeners to notify on changes.
+     * 
+     * @return a new view instance
+     */
+    IRegistryView createView();
+    /**
+     * Creates a view which contains registered query specifications that are considered relevant by the passed filter.
+     * This view will also be incrementally updated on registry changes and accepts listeners to notify on changes.
+     * 
+     * @return a new filtered view instance
+     */
+    IRegistryView createView(IRegistryViewFilter filter);
+    
+    /**
+     * Creates a view which is instantiated by the factory and is connected to the registry. This
+     * view will also be incrementally updated on registry changes and accepts listeners to notify on changes.
+     * 
+     * @return a new view instance
+     */
+    IRegistryView createView(IRegistryViewFactory factory);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IQuerySpecificationRegistryChangeListener.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IQuerySpecificationRegistryChangeListener.java
new file mode 100644
index 00000000..defdd2ab
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IQuerySpecificationRegistryChangeListener.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry;
+/**
+ * Listener interface for providing update notifications of views to users. It is used for propagating changes from the
+ * query specification registry to the views and from the views to users.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public interface IQuerySpecificationRegistryChangeListener {
+    /**
+     * Called when a new entry is added to the registry.
+     * 
+     * @param entry that is added
+     */
+    void entryAdded(IQuerySpecificationRegistryEntry entry);
+    /**
+     * Called when an existing entry is removed from the registry.
+     *  
+     * @param entry that is removed
+     */
+    void entryRemoved(IQuerySpecificationRegistryEntry entry);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IQuerySpecificationRegistryEntry.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IQuerySpecificationRegistryEntry.java
new file mode 100644
index 00000000..5009d74b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IQuerySpecificationRegistryEntry.java
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry;
+import tools.refinery.viatra.runtime.extensibility.IQuerySpecificationProvider;
+/**
+ * The query specification registry entry interface can return the identifier of the source that added it to the
+ * registry. It is provider based and can delay class loading of the wrapped {@link IQuerySpecification} until needed.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public interface IQuerySpecificationRegistryEntry extends IQuerySpecificationProvider {
+    /**
+     * @return the identifier of the registry source that contributed the specification
+     */
+    String getSourceIdentifier();
+    
+    /**
+     * Returns whether the query specification was provided by an identifiable project.
+     */
+    boolean isFromProject();
+    
+    /**
+     * Collects the name of the project that is registered this specification to the registry.
+     *  If {@link #getSourceIdentifier()} is false, it returns null.
+     */
+    String getSourceProjectName();
+    /**
+     * @return true if the entry should be included in default views (created without any filters)
+     */
+    boolean includeInDefaultViews();
+    
+    /**
+     * @return the wrapped {@link IQuerySpecificationProvider} or itself
+     */
+    IQuerySpecificationProvider getProvider();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistrySourceConnector.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistrySourceConnector.java
new file mode 100644
index 00000000..94c68d1b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistrySourceConnector.java
@@ -0,0 +1,50 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry;
+/**
+ * A registry source connector can provide query specifications to listeners (e.g. {@link IQuerySpecificationRegistry}).
+ * The connector interface does not support direct access to query specifications, instead it sends existing specifications
+ * to listeners on addition and sends notifications to listeners when a change occurs in the set of specifications.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public interface IRegistrySourceConnector {
+    /**
+     * The connector must return the same identifier every time it is invoked!
+     * 
+     * @return unique identifier of the connector
+     */
+    String getIdentifier();
+    /**
+     * 
+     * @return true if the specifications of the connector should be included in default views
+     */
+    boolean includeSpecificationsInDefaultViews();
+    
+    /**
+     * Add a listener to get updates on changes in the query specifications available from the connector. When the
+     * listener is added, the connector is expected to call the listener with each existing query specification.
+     * 
+     * @param listener that should be added
+     */
+    void addListener(IConnectorListener listener);
+    /**
+     * Removes an already registered listener and stops sending updates. The connector is not required to send any
+     * updates before returning from this method, but should not send any events after this method returns.
+     * 
+     * @param listener that should be removed
+     */
+    void removeListener(IConnectorListener listener);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistryView.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistryView.java
new file mode 100644
index 00000000..acf49b76
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistryView.java
@@ -0,0 +1,72 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry;
+import java.util.Set;
+/**
+ * The registry view is the primary interface for users to interact with the query specifications in an
+ * {@link IQuerySpecificationRegistry}. Views are created using the createView methods of registry and their content is
+ * also dynamically updated by the registry.
+ * 
+ * The view contains a set of {@link IQuerySpecificationRegistryEntry} objects that can be used to access the query
+ * specifications themselves through the get() method.
+ * 
+ * Users can check the contents of the view and add listeners to get notifications on view changes (added or removed
+ * entries).
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public interface IRegistryView extends IQuerySpecificationRegistryChangeListener {
+    /**
+     * @return an immutable copy of all entries found in the view
+     */
+    Iterable<IQuerySpecificationRegistryEntry> getEntries();
+    /**
+     * @return the set of FQNs for the query specifications in the view
+     */
+    Set<String> getQuerySpecificationFQNs();
+    /**
+     * @param fullyQualifiedName
+     *            that is looked up in the view
+     * @return true if the view contains an entry with given FQN, false otherwise
+     */
+    boolean hasQuerySpecificationFQN(String fullyQualifiedName);
+    /**
+     * @param fullyQualifiedName
+     *            of the entries that are requested
+     * @return the possible empty set of entries with the given FQN
+     */
+    Set<IQuerySpecificationRegistryEntry> getEntries(String fullyQualifiedName);
+    /**
+     * Adds a listener to the view that will be notified when an entry is added to or removed from the view.
+     * 
+     * @param listener that is added
+     */
+    void addViewListener(IQuerySpecificationRegistryChangeListener listener);
+    /**
+     * Removes a listener that was previously added to the view.
+     * 
+     * @param listener that is removed
+     */
+    void removeViewListener(IQuerySpecificationRegistryChangeListener listener);
+    /**
+     * @return the registry underlying the view
+     */
+    IQuerySpecificationRegistry getRegistry();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistryViewFactory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistryViewFactory.java
new file mode 100644
index 00000000..990902d3
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistryViewFactory.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry;
+/**
+ * This interface can be used to ask the registry to construct specific view instances. The factory is responsible for
+ * instantiating the view, but the registry is responsible for establishing the connection with the internal data store
+ * and to fill up the view with entries. Instances of the factory are intended to be passed to
+ * {@link IQuerySpecificationRegistry#createView(IRegistryViewFactory)} and only the view instance returned by that
+ * method can be considered initialized.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public interface IRegistryViewFactory {
+    /**
+     * Instantiate a new view object and store the reference to the registry.
+     * This method should only be called by an {@link IQuerySpecificationRegistry}.
+     * 
+     * @param registry that will be connected to the view
+     * @return the new instance of the view
+     * @noreference This method is not intended to be referenced by clients.
+     */
+    IRegistryView createView(IQuerySpecificationRegistry registry);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistryViewFilter.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistryViewFilter.java
new file mode 100644
index 00000000..fa13327f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/IRegistryViewFilter.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry;
+/**
+ * The registry view filter can control which entries are added and removed from an {@link IRegistryView}.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public interface IRegistryViewFilter {
+    /**
+     * This method controls whether a registry entry is added to the view or not. The filtering is called before
+     * checking the uniqueness of fully qualified names, and relevant entries can overwrite existing entries with the
+     * same FQN.
+     * 
+     * Note that filters should usually return the same value for the same entry on multiple invocations.
+     * 
+     * @param entry
+     *            that is checked
+     * @return true, if the entry is relevant for the view, false otherwise
+     */
+    boolean isEntryRelevant(IQuerySpecificationRegistryEntry entry);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/QuerySpecificationRegistry.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/QuerySpecificationRegistry.java
new file mode 100644
index 00000000..139dde1c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/QuerySpecificationRegistry.java
@@ -0,0 +1,112 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+import tools.refinery.viatra.runtime.registry.impl.QuerySpecificationRegistryImpl;
+/**
+ * Registry for query specifications that can be accessed using fully qualified names through views.
+ * Additional query specifications can be added using {@link IRegistrySourceConnector}s.
+ * 
+ * <p>
+ * When running as an OSGi plug-in, the generated query specifications registered through extensions are automatically loaded
+ * into the registry by the {@link ExtensionBasedQuerySpecificationLoader} class.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public class QuerySpecificationRegistry implements IQuerySpecificationRegistry {
+    private static final QuerySpecificationRegistry INSTANCE = new QuerySpecificationRegistry();
+    /**
+     * @return the singleton query specification registry instance
+     */
+    public static IQuerySpecificationRegistry getInstance() {
+        return INSTANCE;
+    }
+    
+    private final QuerySpecificationRegistryImpl internalRegistry;
+    /**
+     * Connectors that should not be immediately loaded into the registry.
+     */
+    private final Set<IRegistrySourceConnector> delayedConnectors;
+    
+    /**
+     * Hidden constructor for singleton instance
+     */
+    protected QuerySpecificationRegistry() {
+        this.internalRegistry = new QuerySpecificationRegistryImpl();
+        this.delayedConnectors = new HashSet<>();
+        
+    }
+    
+    /**
+     * @return the internal registry after adding delayed source connectors
+     */
+    protected IQuerySpecificationRegistry getInternalRegistry() {
+        if(!delayedConnectors.isEmpty()) {
+            final Iterator<IRegistrySourceConnector> it = delayedConnectors.iterator();
+            while (it.hasNext()) {
+                final IRegistrySourceConnector connector = it.next();
+                internalRegistry.addSource(connector);
+                it.remove();
+            }
+        }
+        return internalRegistry;
+    }
+    
+    /**
+     * When the registry adds itself as a listener to connectors, it must send all specification providers
+     * to the registry. However, when {@link ExtensionBasedQuerySpecificationLoader} is triggered during the
+     * activation of the plugin, the individual query specification classes cannot be loaded yet. To avoid this, 
+     * the connector of the loader is delayed until needed.
+     * 
+     * @param connector that should be delayed before adding to the registry
+     */
+    protected void addDelayedSourceConnector(IRegistrySourceConnector connector) {
+        delayedConnectors.add(connector);
+    }
+    
+    @Override
+    public boolean addSource(IRegistrySourceConnector connector) {
+        return getInternalRegistry().addSource(connector);
+    }
+    @Override
+    public boolean removeSource(IRegistrySourceConnector connector) {
+        return getInternalRegistry().removeSource(connector);
+    }
+    @Override
+    public IDefaultRegistryView getDefaultView() {
+        return getInternalRegistry().getDefaultView();
+    }
+    @Override
+    public IRegistryView createView() {
+        return getInternalRegistry().createView();
+    }
+    @Override
+    public IRegistryView createView(IRegistryViewFilter filter) {
+        return getInternalRegistry().createView(filter);
+    }
+    @Override
+    public IRegistryView createView(IRegistryViewFactory factory) {
+        return getInternalRegistry().createView(factory);
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/connector/AbstractRegistrySourceConnector.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/connector/AbstractRegistrySourceConnector.java
new file mode 100644
index 00000000..0e2ef273
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/connector/AbstractRegistrySourceConnector.java
@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry.connector;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+import tools.refinery.viatra.runtime.registry.IConnectorListener;
+import tools.refinery.viatra.runtime.registry.IRegistrySourceConnector;
+/**
+ * Abstract registry source connector implementation that stores the identifier and listener set.
+ * 
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public abstract class AbstractRegistrySourceConnector implements IRegistrySourceConnector {
+    protected Set<IConnectorListener> listeners;
+    private String identifier;
+    private boolean includeInDefaultViews;
+    /**
+     * Creates an instance of the connector with the given identifier. The identifier should be unique if you want to
+     * add it to a registry as a source.
+     * 
+     * @param identifier
+     *            of the newly created connector
+     * @param includeInDefaultViews
+     *            true if the specifications in the connector should be included in default views
+     */
+    public AbstractRegistrySourceConnector(String identifier, boolean includeInDefaultViews) {
+        super();
+        Objects.requireNonNull(identifier, "Identifier must not be null!");
+        this.identifier = identifier;
+        this.includeInDefaultViews = includeInDefaultViews;
+        this.listeners = new HashSet<>();
+    }
+    @Override
+    public String getIdentifier() {
+        return identifier;
+    }
+    
+    @Override
+    public boolean includeSpecificationsInDefaultViews() {
+        return includeInDefaultViews;
+    }
+    @Override
+    public void addListener(IConnectorListener listener) {
+        Objects.requireNonNull(listener, "Listener must not be null!");
+        boolean added = listeners.add(listener);
+        if (added) {
+            sendQuerySpecificationsToListener(listener);
+        }
+    }
+    @Override
+    public void removeListener(IConnectorListener listener) {
+        Objects.requireNonNull(listener, "Listener must not be null!");
+        listeners.remove(listener);
+    }
+    /**
+     * Subclasses should send add notifications for each specification in the connector to the given listener.
+     * 
+     * @param listener that should receive the notifications
+     */
+    protected abstract void sendQuerySpecificationsToListener(IConnectorListener listener);
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/connector/QueryGroupProviderSourceConnector.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/connector/QueryGroupProviderSourceConnector.java
new file mode 100644
index 00000000..e6f0adf0
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/connector/QueryGroupProviderSourceConnector.java
@@ -0,0 +1,80 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry.connector;
+import java.util.Objects;
+import tools.refinery.viatra.runtime.extensibility.IQueryGroupProvider;
+import tools.refinery.viatra.runtime.extensibility.IQuerySpecificationProvider;
+import tools.refinery.viatra.runtime.registry.IConnectorListener;
+/**
+ * Source connector implementation that uses a {@link IQueryGroupProvider} to provide a query specifications into the
+ * registry. The query group can be later updated which triggers the removal of all specifications of the old group and
+ * the addition of all specifications from the new group.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public class QueryGroupProviderSourceConnector extends AbstractRegistrySourceConnector {
+    IQueryGroupProvider queryGroupProvider;
+    /**
+     * Creates an instance of the connector with the given identifier and the query group provider. The identifier
+     * should be unique if you want to add it to a registry as a source.
+     * 
+     * @param identifier
+     *            of the newly created connector
+     * @param provider
+     *            that contains the query specifications handled by the connector
+     * @param includeInDefaultViews
+     *            true if the specifications in the connector should be included in default views
+     */
+    public QueryGroupProviderSourceConnector(String identifier, IQueryGroupProvider provider, boolean includeInDefaultViews) {
+        super(identifier, includeInDefaultViews);
+        this.queryGroupProvider = provider;
+    }
+    /**
+     * Update the query group of the connector, which triggers the removal of all specifications on the old group and
+     * addition of all specifications in the given group.
+     * 
+     * @param queryGroupProvider
+     *            the queryGroupProvider to set
+     * @param includeInDefaultViews
+     *            true if the specifications in the connector should be included in default views
+     */
+    public void setQueryGroupProvider(IQueryGroupProvider queryGroupProvider) {
+        Objects.requireNonNull(queryGroupProvider, "Query group provider must not be null!");
+        IQueryGroupProvider oldProvider = this.queryGroupProvider;
+        for (IQuerySpecificationProvider specificationProvider : oldProvider.getQuerySpecificationProviders()) {
+            for (IConnectorListener iConnectorListener : listeners) {
+                iConnectorListener.querySpecificationRemoved(this, specificationProvider);
+            }
+        }
+        for (IQuerySpecificationProvider specificationProvider : queryGroupProvider.getQuerySpecificationProviders()) {
+            for (IConnectorListener iConnectorListener : listeners) {
+                iConnectorListener.querySpecificationAdded(this, specificationProvider);
+            }
+        }
+        this.queryGroupProvider = queryGroupProvider;
+    }
+    @Override
+    protected void sendQuerySpecificationsToListener(IConnectorListener listener) {
+        for (IQuerySpecificationProvider specificationProvider : queryGroupProvider.getQuerySpecificationProviders()) {
+            listener.querySpecificationAdded(this, specificationProvider);
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/connector/SpecificationMapSourceConnector.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/connector/SpecificationMapSourceConnector.java
new file mode 100644
index 00000000..e5778950
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/connector/SpecificationMapSourceConnector.java
@@ -0,0 +1,147 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry.connector;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.Set;
+import tools.refinery.viatra.runtime.extensibility.IQuerySpecificationProvider;
+import tools.refinery.viatra.runtime.extensibility.SingletonQuerySpecificationProvider;
+import tools.refinery.viatra.runtime.registry.IConnectorListener;
+/**
+ * A simple connector implementation that allows users to simply add and remove specifications. These changes are
+ * propagated to listeners (e.g. the registry). Note that duplicate FQNs are not allowed in a given connector.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ *
+ */
+public class SpecificationMapSourceConnector extends AbstractRegistrySourceConnector {
+    private static final String DUPLICATE_MESSAGE = "Duplicate FQN %s cannot be added to connector";
+    private Map<String, IQuerySpecificationProvider> specificationProviderMap;
+    /**
+     * Creates an instance of the connector with the given identifier. The identifier should be unique if you want to
+     * add it to a registry as a source.
+     * 
+     * @param identifier
+     *            of the newly created connector
+     * @param includeInDefaultViews
+     *            true if the specifications in the connector should be included in default views
+     */
+    public SpecificationMapSourceConnector(String identifier, boolean includeInDefaultViews) {
+        super(identifier, includeInDefaultViews);
+        this.specificationProviderMap = new HashMap<>();
+    }
+    
+    /**
+     * Creates an instance of the connector with the given identifier and fills it up with the given specification
+     * providers. The identifier should be unique if you want to add it to a registry as a source.
+     * 
+     * @param identifier
+     *            of the newly created connector
+     * @param specificationProviders
+     *            the initial set of specifications in the connector
+     * @param includeInDefaultViews
+     *            true if the specifications in the connector should be included in default views
+     */
+    public SpecificationMapSourceConnector(String identifier, Set<IQuerySpecificationProvider> specificationProviders, boolean includeInDefaultViews) {
+        this(identifier, includeInDefaultViews);
+        for (IQuerySpecificationProvider provider : specificationProviders) {
+            addQuerySpecificationProvider(provider);
+        }
+    }
+    /**
+     * Creates an instance of the connector with the given identifier and fills it up with the specification providers
+     * from the given {@link SpecificationMapSourceConnector}. The identifier should be unique if you want to add it to
+     * a registry as a source.
+     * 
+     * @param identifier
+     *            of the newly created connector
+     * @param connector
+     *            that contains the specifications to copy into the new instance
+     * @param includeInDefaultViews
+     *            true if the specifications in the connector should be included in default views
+     */
+    public SpecificationMapSourceConnector(String identifier, SpecificationMapSourceConnector connector, boolean includeInDefaultViews) {
+        this(identifier, includeInDefaultViews);
+        this.specificationProviderMap.putAll(connector.specificationProviderMap);
+    }
+    /**
+     * Adds a query specification to the connector.
+     * If you have an {@link IQuerySpecification} object, use {@link SingletonQuerySpecificationProvider}.
+     * 
+     * @param provider to add to the connector
+     * @throws IllegalArgumentException if the connector already contains a specification with the same FQN
+     */
+    public void addQuerySpecificationProvider(IQuerySpecificationProvider provider) {
+        Objects.requireNonNull(provider, "Provider must not be null!");
+        String fullyQualifiedName = provider.getFullyQualifiedName();
+        if (!specificationProviderMap.containsKey(fullyQualifiedName)) {
+            specificationProviderMap.put(fullyQualifiedName, provider);
+            for (IConnectorListener listener : listeners) {
+                listener.querySpecificationAdded(this, provider);
+            }
+        } else {
+            throw new IllegalArgumentException(String.format(DUPLICATE_MESSAGE, fullyQualifiedName));
+        }
+    }
+    /**
+     * Remove a specification that has been added with the given FQN.
+     * 
+     * @param fullyQualifiedName
+     * @throws NoSuchElementException if the connector does not contain a specification with the given FQN
+     */
+    public void removeQuerySpecificationProvider(String fullyQualifiedName) {
+        Objects.requireNonNull(fullyQualifiedName, "Fully qualified name must not be null!");
+        IQuerySpecificationProvider provider = specificationProviderMap.remove(fullyQualifiedName);
+        if (provider == null) {
+            throw new NoSuchElementException(
+                    String.format("Connector does not contain specification with FQN %s", fullyQualifiedName));
+        }
+        for (IConnectorListener listener : listeners) {
+            listener.querySpecificationRemoved(this, provider);
+        }
+    }
+    /**
+     * @return the immutable copy of the set of FQNs for the added query specifications
+     */
+    public Set<String> getQuerySpecificationFQNs() {
+        return Collections.unmodifiableSet(new HashSet<>(specificationProviderMap.keySet()));
+    }
+    /**
+     * 
+     * @param fullyQualifiedName that is checked
+     * @return true if a specification with the given FQN exists in the connector, false otherwise
+     */
+    public boolean hasQuerySpecificationFQN(String fullyQualifiedName) {
+        Objects.requireNonNull(fullyQualifiedName, "FQN must not be null!");
+        return specificationProviderMap.containsKey(fullyQualifiedName);
+    }
+    @Override
+    protected void sendQuerySpecificationsToListener(IConnectorListener listener) {
+        for (IQuerySpecificationProvider provider : specificationProviderMap.values()) {
+            listener.querySpecificationAdded(this, provider);
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/data/QuerySpecificationStore.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/data/QuerySpecificationStore.java
new file mode 100644
index 00000000..649527b6
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/data/QuerySpecificationStore.java
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry.data;
+import java.util.Map;
+import java.util.TreeMap;
+/**
+ * Internal data storage object that represents a query specification registry with a set of sources driven by
+ * connectors. The sources must have unique identifiers.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public class QuerySpecificationStore {
+    private Map<String, RegistrySourceImpl> sources;
+    /**
+     * Creates a new instance with an empty identifier to source map.
+     */
+    public QuerySpecificationStore() {
+        this.sources = new TreeMap<>();
+    }
+    /**
+     * @return the live, modifiable identifier to source map
+     */
+    public Map<String, RegistrySourceImpl> getSources() {
+        return sources;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/data/RegistryEntryImpl.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/data/RegistryEntryImpl.java
new file mode 100644
index 00000000..758885e2
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/data/RegistryEntryImpl.java
@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry.data;
+import tools.refinery.viatra.runtime.api.IQuerySpecification;
+import tools.refinery.viatra.runtime.extensibility.IQuerySpecificationProvider;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistryEntry;
+/**
+ * Internal data storage object that represents a query specification entry. The entry contains an
+ * {@link IQuerySpecificationProvider} and has a reference to the source that contains it.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public class RegistryEntryImpl implements IQuerySpecificationRegistryEntry {
+    private IQuerySpecificationProvider provider;
+    private RegistrySourceImpl source;
+    /**
+     * Creates a new instance with the given source and the given provider.
+     * 
+     * @param source
+     *            that contains the new entry
+     * @param provider
+     *            that wraps the specification represented by the entry
+     */
+    public RegistryEntryImpl(RegistrySourceImpl source, IQuerySpecificationProvider provider) {
+        this.source = source;
+        this.provider = provider;
+    }
+    /**
+     * @return the source that contains this entry
+     */
+    public RegistrySourceImpl getSource() {
+        return source;
+    }
+    @Override
+    public String getSourceIdentifier() {
+        return source.getIdentifier();
+    }
+    @Override
+    public boolean includeInDefaultViews() {
+        return getSource().includeEntriesInDefaultViews();
+    }
+    @Override
+    public String getFullyQualifiedName() {
+        return provider.getFullyQualifiedName();
+    }
+    @Override
+    public IQuerySpecification<?> get() {
+        return provider.get();
+    }
+    @Override
+    public IQuerySpecificationProvider getProvider() {
+        return provider;
+    }
+    @Override
+    public boolean isFromProject() {
+        return provider.getSourceProjectName() != null;
+    }
+    @Override
+    public String getSourceProjectName() {
+        return provider.getSourceProjectName();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/data/RegistrySourceImpl.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/data/RegistrySourceImpl.java
new file mode 100644
index 00000000..83c3b920
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/data/RegistrySourceImpl.java
@@ -0,0 +1,73 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry.data;
+import java.util.Map;
+import java.util.TreeMap;
+/**
+ * Internal data storage object that represents a query specification source driven by a connector. The source must have
+ * unique identifier that is copied from the connector. The source uses a FQN to entry map to manage registry entries.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public class RegistrySourceImpl {
+    private String identifier;
+    private boolean includeInDefaultViews;
+    private QuerySpecificationStore querySpecificationStore;
+    private Map<String, RegistryEntryImpl> fqnToEntryMap;
+    /**
+     * Creates a new source with the given identifier and an empty entry map.
+     * 
+     * @param identifier
+     *            for the source
+     * @param querySpecificationStore
+     *            that contains this source
+     * @param includeInDefaultViews
+     *            true if the entries of the source should be included in default views
+     */
+    public RegistrySourceImpl(String identifier, QuerySpecificationStore querySpecificationStore, boolean includeInDefaultViews) {
+        this.identifier = identifier;
+        this.includeInDefaultViews = includeInDefaultViews;
+        this.querySpecificationStore = querySpecificationStore;
+        this.fqnToEntryMap = new TreeMap<>();
+    }
+    /**
+     * @return the identifier of the source
+     */
+    public String getIdentifier() {
+        return identifier;
+    }
+    /**
+     * @return true if the entries in the source should be included in default views
+     */
+    public boolean includeEntriesInDefaultViews() {
+        return includeInDefaultViews;
+    }
+    
+    /**
+     * @return the store that contains the source
+     */
+    public QuerySpecificationStore getStore() {
+        return querySpecificationStore;
+    }
+    /**
+     * @return the live, modifiable FQN to entry map 
+     */
+    public Map<String, RegistryEntryImpl> getFqnToEntryMap() {
+        return fqnToEntryMap;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/FilteringRegistryView.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/FilteringRegistryView.java
new file mode 100644
index 00000000..164a30d3
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/FilteringRegistryView.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry.impl;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistry;
+import tools.refinery.viatra.runtime.registry.IRegistryViewFilter;
+import tools.refinery.viatra.runtime.registry.view.AbstractRegistryView;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistryEntry;
+/**
+ * Registry view implementation that uses a filter to delegate the decision on whether 
+ * a given specification is relevant to the view.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public class FilteringRegistryView extends AbstractRegistryView {
+    private IRegistryViewFilter filter;
+    /**
+     * Creates a new filtering view instance.
+     * 
+     * @param registry that defines the view
+     * @param filter that is used for deciding relevancy
+     */
+    public FilteringRegistryView(IQuerySpecificationRegistry registry, IRegistryViewFilter filter, boolean allowDuplicateFQNs) {
+        super(registry, allowDuplicateFQNs);
+        this.filter = filter;
+    }
+    @Override
+    protected boolean isEntryRelevant(IQuerySpecificationRegistryEntry entry) {
+        return filter.isEntryRelevant(entry);
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/GlobalRegistryView.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/GlobalRegistryView.java
new file mode 100644
index 00000000..75d730b6
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/GlobalRegistryView.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry.impl;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.api.IQueryGroup;
+import tools.refinery.viatra.runtime.api.LazyLoadingQueryGroup;
+import tools.refinery.viatra.runtime.registry.IDefaultRegistryView;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistry;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistryEntry;
+import tools.refinery.viatra.runtime.registry.view.AbstractRegistryView;
+/**
+ * Registry view implementation that considers specifications relevant if they are included in default views.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public class GlobalRegistryView extends AbstractRegistryView implements IDefaultRegistryView {
+    
+    /**
+     * Creates a new instance of the global view.
+     * 
+     * @param registry that defines the view
+     */
+    public GlobalRegistryView(IQuerySpecificationRegistry registry) {
+        super(registry, false);
+    }
+    
+    @Override
+    protected boolean isEntryRelevant(IQuerySpecificationRegistryEntry entry) {
+        return entry.includeInDefaultViews();
+    }
+    
+    @Override
+    public IQueryGroup getQueryGroup() {
+        Set<IQuerySpecificationRegistryEntry> allQueries = 
+                fqnToEntryMap.distinctValuesStream().collect(Collectors.toSet());
+        IQueryGroup queryGroup = LazyLoadingQueryGroup.of(allQueries); 
+        return queryGroup;
+    }
+    @Override
+    public IQuerySpecificationRegistryEntry getEntry(String fullyQualifiedName) {
+        Set<IQuerySpecificationRegistryEntry> entries = getEntries(fullyQualifiedName);
+        if(entries.isEmpty()){
+            throw new NoSuchElementException("Cannot find entry with FQN " + fullyQualifiedName);
+        }
+        if(entries.size() > 1) {
+            throw new IllegalStateException("Global view must never contain duplicated FQNs!");
+        }
+        IQuerySpecificationRegistryEntry entry = entries.iterator().next();
+        return entry;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/QuerySpecificationRegistryImpl.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/QuerySpecificationRegistryImpl.java
new file mode 100644
index 00000000..63306e93
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/QuerySpecificationRegistryImpl.java
@@ -0,0 +1,177 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry.impl;
+import static tools.refinery.viatra.runtime.matchers.util.Preconditions.checkArgument;
+import java.util.Map;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.extensibility.IQuerySpecificationProvider;
+import tools.refinery.viatra.runtime.registry.IConnectorListener;
+import tools.refinery.viatra.runtime.registry.IDefaultRegistryView;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistry;
+import tools.refinery.viatra.runtime.registry.IRegistryView;
+import tools.refinery.viatra.runtime.registry.IRegistryViewFactory;
+import tools.refinery.viatra.runtime.registry.IRegistryViewFilter;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistryChangeListener;
+import tools.refinery.viatra.runtime.registry.IRegistrySourceConnector;
+import tools.refinery.viatra.runtime.registry.data.QuerySpecificationStore;
+import tools.refinery.viatra.runtime.registry.data.RegistryEntryImpl;
+import tools.refinery.viatra.runtime.registry.data.RegistrySourceImpl;
+import tools.refinery.viatra.runtime.util.ViatraQueryLoggingUtil;
+/**
+ * This is the default implementation of the {@link IQuerySpecificationRegistry} interface.
+ * It uses a {@link QuerySpecificationStore} to keep track of sources and entries.
+ * It uses a {@link RegistryChangeMultiplexer} to update all views and a single {@link IConnectorListener}
+ * to subscribe to sources added to the registry.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public class QuerySpecificationRegistryImpl implements IQuerySpecificationRegistry {
+    private static final String CONNECTOR_NULL_MSG = "Connector cannot be null";
+    private final QuerySpecificationStore querySpecificationStore;
+    private final IConnectorListener connectorListener;
+    private final RegistryChangeMultiplexer multiplexer;
+    private final Logger logger;
+    private IDefaultRegistryView defaultView = null;
+    
+    /**
+     * Creates a new instance of the registry
+     */
+    public QuerySpecificationRegistryImpl() {
+        this.querySpecificationStore = new QuerySpecificationStore();
+        this.connectorListener = new RegistryUpdaterConnectorListener();
+        this.multiplexer = new RegistryChangeMultiplexer();
+        this.logger = ViatraQueryLoggingUtil.getLogger(IQuerySpecificationRegistry.class);
+    }
+    
+    @Override
+    public boolean addSource(IRegistrySourceConnector connector) {
+        checkArgument(connector != null, CONNECTOR_NULL_MSG);
+        String identifier = connector.getIdentifier();
+        Map<String, RegistrySourceImpl> sources = querySpecificationStore.getSources();
+        if(sources.containsKey(identifier)){
+            return false;
+        }
+        RegistrySourceImpl source = new RegistrySourceImpl(identifier, querySpecificationStore, connector.includeSpecificationsInDefaultViews());
+        sources.put(identifier, source);
+        connector.addListener(connectorListener);
+        logger.debug("Source added: " + source.getIdentifier());
+        return true;
+    }
+    
+    @Override
+    public boolean removeSource(IRegistrySourceConnector connector) {
+        checkArgument(connector != null, CONNECTOR_NULL_MSG);
+        String identifier = connector.getIdentifier();
+        Map<String, RegistrySourceImpl> sources = querySpecificationStore.getSources();
+        if(!sources.containsKey(identifier)){
+            return false;
+        }
+        connector.removeListener(connectorListener);
+        RegistrySourceImpl source = sources.remove(identifier);
+        for (RegistryEntryImpl entry : source.getFqnToEntryMap().values()) {
+            multiplexer.entryRemoved(entry);
+        }
+        logger.debug("Source removed: " + source.getIdentifier());
+        return true;
+    }
+    
+    /**
+     * @return the internal store of the registry
+     */
+    protected QuerySpecificationStore getStore() {
+        return querySpecificationStore;
+    }
+    @Override
+    public IRegistryView createView() {
+        return createGlobalView();
+    }
+    private GlobalRegistryView createGlobalView() {
+        GlobalRegistryView registryView = new GlobalRegistryView(this);
+        initializeChangeListener(registryView);
+        return registryView;
+    }
+    protected void initializeChangeListener(IQuerySpecificationRegistryChangeListener listener) {
+        // send existing entries to aspect
+        for (RegistrySourceImpl source : querySpecificationStore.getSources().values()) {
+            Map<String, RegistryEntryImpl> entryMap = source.getFqnToEntryMap();
+            for (RegistryEntryImpl entry : entryMap.values()) {
+                listener.entryAdded(entry);
+            }
+        }
+        multiplexer.addListener(listener);
+    }
+    @Override
+    public IRegistryView createView(IRegistryViewFilter filter) {
+        checkArgument(filter != null, "Filter cannot be null");
+        FilteringRegistryView registryView = new FilteringRegistryView(this, filter, false);
+        initializeChangeListener(registryView);
+        return registryView;
+    }
+    /**
+     * Internal connector listener implementation for updating internal store and propagating changes to views.
+     * 
+     * @author Abel Hegedus
+     *
+     */
+    private final class RegistryUpdaterConnectorListener implements IConnectorListener {
+        @Override
+        public void querySpecificationAdded(IRegistrySourceConnector connector, IQuerySpecificationProvider specification) {
+            String identifier = connector.getIdentifier();
+            RegistrySourceImpl source = querySpecificationStore.getSources().get(identifier);
+            String fullyQualifiedName = specification.getFullyQualifiedName();
+            RegistryEntryImpl registryEntry = new RegistryEntryImpl(source, specification);
+            RegistryEntryImpl oldEntry = source.getFqnToEntryMap().put(fullyQualifiedName, registryEntry);
+            if(oldEntry != null) {
+                logger.warn(String.format("Specification added with existing FQN %s in source %s", fullyQualifiedName, identifier));
+                multiplexer.entryRemoved(oldEntry);
+            }
+            multiplexer.entryAdded(registryEntry);
+            
+        }
+        @Override
+        public void querySpecificationRemoved(IRegistrySourceConnector connector, IQuerySpecificationProvider specification) {
+            String identifier = connector.getIdentifier();
+            RegistrySourceImpl source = querySpecificationStore.getSources().get(identifier);
+            String fullyQualifiedName = specification.getFullyQualifiedName();
+            RegistryEntryImpl registryEntry = source.getFqnToEntryMap().remove(fullyQualifiedName);
+            if(registryEntry != null) {
+                multiplexer.entryRemoved(registryEntry);
+            }
+        }
+    }
+    @Override
+    public IDefaultRegistryView getDefaultView() {
+        if(this.defaultView == null){
+            this.defaultView = createGlobalView();
+        }
+        return this.defaultView;
+    }
+    @Override
+    public IRegistryView createView(IRegistryViewFactory factory) {
+        IRegistryView registryView = factory.createView(this);
+        initializeChangeListener(registryView);
+        return registryView;
+    }
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/RegistryChangeMultiplexer.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/RegistryChangeMultiplexer.java
new file mode 100644
index 00000000..450f36b8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/impl/RegistryChangeMultiplexer.java
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry.impl;
+import java.util.Collections;
+import java.util.Set;
+import java.util.WeakHashMap;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistryChangeListener;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistryEntry;
+/**
+ * Listener implementation that propagates all changes to a set of listeners.
+ * The listeners are stored with weak references to avoid a need for disposal.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public class RegistryChangeMultiplexer implements IQuerySpecificationRegistryChangeListener {
+    private Set<IQuerySpecificationRegistryChangeListener> listeners;
+    
+    /**
+     * Creates a new instance of the multiplexer.
+     */
+    public RegistryChangeMultiplexer() {
+        this.listeners = Collections.newSetFromMap(new WeakHashMap<IQuerySpecificationRegistryChangeListener, Boolean>());
+    }
+    
+    /**
+     * Adds a weak reference on the listener to the multiplexer. The listener will receive all further notifications and
+     * does not have to be removed, since the multiplexer will not keep it in memory when it can be collected.
+     */
+    public boolean addListener(IQuerySpecificationRegistryChangeListener listener) {
+        return listeners.add(listener);
+    }
+    
+    @Override
+    public void entryAdded(IQuerySpecificationRegistryEntry entry) {
+        for (IQuerySpecificationRegistryChangeListener listener : listeners) {
+            listener.entryAdded(entry);
+        }
+    }
+    @Override
+    public void entryRemoved(IQuerySpecificationRegistryEntry entry) {
+        for (IQuerySpecificationRegistryChangeListener listener : listeners) {
+            listener.entryRemoved(entry);
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/view/AbstractRegistryView.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/view/AbstractRegistryView.java
new file mode 100644
index 00000000..7b3c34ba
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/registry/view/AbstractRegistryView.java
@@ -0,0 +1,150 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.registry.view;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistry;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistryChangeListener;
+import tools.refinery.viatra.runtime.registry.IQuerySpecificationRegistryEntry;
+import tools.refinery.viatra.runtime.registry.IRegistryView;
+import tools.refinery.viatra.runtime.util.ViatraQueryLoggingUtil;
+/**
+ * An abstract {@link IRegistryView} implementation that stores the registry, the set of listeners added to the view and
+ * the FQN to entry map of the view itself. The only responsibility of subclasses is to decide whether an entry received
+ * as an addition or removal notification is relevant to the view.
+ * 
+ * @author Abel Hegedus
+ * @since 1.3
+ */
+public abstract class AbstractRegistryView implements IRegistryView {
+    private static final String LISTENER_EXCEPTION_REMOVE = "Exception occurred while notifying view listener %s about entry removal";
+    private static final String LISTENER_EXCEPTION_ADD = "Exception occurred while notifying view listener %s about entry addition";
+    protected final IQuerySpecificationRegistry registry;
+    protected final IMultiLookup<String, IQuerySpecificationRegistryEntry> fqnToEntryMap;
+    protected final Set<IQuerySpecificationRegistryChangeListener> listeners;
+    protected final boolean allowDuplicateFQNs;
+    /**
+     * This method is called both when an addition or removal notification is received from the registry. Subclasses can
+     * implement view filtering by returning false for those specifications that are not relevant for this view.
+     * 
+     * @param entry
+     *            that is added or removed in the registry
+     * @return true if the entry should be added to or removed from the view, false otherwise
+     */
+    protected abstract boolean isEntryRelevant(IQuerySpecificationRegistryEntry entry);
+    /**
+     * Creates a new view instance for the given registry. Note that views are created by the registry and the view
+     * update mechanisms are also set up by the registry.
+     * 
+     * @param registry
+     */
+    public AbstractRegistryView(IQuerySpecificationRegistry registry, boolean allowDuplicateFQNs) {
+        this.registry = registry;
+        this.allowDuplicateFQNs = allowDuplicateFQNs;
+        this.fqnToEntryMap = CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+        this.listeners = new HashSet<>();
+    }
+    @Override
+    public IQuerySpecificationRegistry getRegistry() {
+        return registry;
+    }
+    @Override
+    public Iterable<IQuerySpecificationRegistryEntry> getEntries() {
+        return fqnToEntryMap.distinctValuesStream().collect(Collectors.toSet());
+    }
+    @Override
+    public Set<String> getQuerySpecificationFQNs() {
+        return fqnToEntryMap.distinctKeysStream().collect(Collectors.toSet());
+    }
+    @Override
+    public boolean hasQuerySpecificationFQN(String fullyQualifiedName) {
+        Preconditions.checkArgument(fullyQualifiedName != null, "FQN must not be null!");
+        return fqnToEntryMap.lookupExists(fullyQualifiedName);
+    }
+    @Override
+    public Set<IQuerySpecificationRegistryEntry> getEntries(String fullyQualifiedName) {
+        Preconditions.checkArgument(fullyQualifiedName != null, "FQN must not be null!");
+        IMemoryView<IQuerySpecificationRegistryEntry> entries = fqnToEntryMap.lookupOrEmpty(fullyQualifiedName);
+        return Collections.unmodifiableSet(entries.distinctValues());
+    }
+    @Override
+    public void addViewListener(IQuerySpecificationRegistryChangeListener listener) {
+        Preconditions.checkArgument(listener != null, "Null listener not supported");
+        listeners.add(listener);
+    }
+    @Override
+    public void removeViewListener(IQuerySpecificationRegistryChangeListener listener) {
+        Preconditions.checkArgument(listener != null, "Null listener not supported");
+        listeners.remove(listener);
+    }
+    @Override
+    public void entryAdded(IQuerySpecificationRegistryEntry entry) {
+        if (isEntryRelevant(entry)) {
+            String fullyQualifiedName = entry.getFullyQualifiedName();
+            IMemoryView<IQuerySpecificationRegistryEntry> duplicates = fqnToEntryMap.lookup(fullyQualifiedName);
+            if(!allowDuplicateFQNs && duplicates != null) {
+                Set<IQuerySpecificationRegistryEntry> removed = new HashSet<>(duplicates.distinctValues());
+                for (IQuerySpecificationRegistryEntry e : removed) {
+                    fqnToEntryMap.removePair(fullyQualifiedName, e);
+                    notifyListeners(e, false);
+                }
+            }
+            fqnToEntryMap.addPair(fullyQualifiedName, entry);
+            notifyListeners(entry, true);
+        }
+    }
+    @Override
+    public void entryRemoved(IQuerySpecificationRegistryEntry entry) {
+        if (isEntryRelevant(entry)) {
+            String fullyQualifiedName = entry.getFullyQualifiedName();
+            fqnToEntryMap.removePair(fullyQualifiedName, entry);
+            notifyListeners(entry, false);
+        }
+    }
+    private void notifyListeners(IQuerySpecificationRegistryEntry entry, boolean addition) {
+        for (IQuerySpecificationRegistryChangeListener listener : listeners) {
+            try {
+                if(addition){
+                    listener.entryAdded(entry);
+                } else {
+                    listener.entryRemoved(entry);
+                }
+            } catch (Exception ex) {
+                Logger logger = ViatraQueryLoggingUtil.getLogger(AbstractRegistryView.class);
+                String formatString = addition ? LISTENER_EXCEPTION_ADD : LISTENER_EXCEPTION_REMOVE;
+                logger.error(String.format(formatString, listener), ex);
+            }
+        }
+    }
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/tabular/EcoreIndexHost.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/tabular/EcoreIndexHost.java
new file mode 100644
index 00000000..e87a726a
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/tabular/EcoreIndexHost.java
@@ -0,0 +1,166 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.tabular;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.EcorePackage;
+import tools.refinery.viatra.runtime.api.scope.QueryScope;
+import tools.refinery.viatra.runtime.emf.EMFQueryMetaContext;
+import tools.refinery.viatra.runtime.emf.EMFScope;
+import tools.refinery.viatra.runtime.emf.types.EClassExactInstancesKey;
+import tools.refinery.viatra.runtime.emf.types.EClassTransitiveInstancesKey;
+import tools.refinery.viatra.runtime.emf.types.EDataTypeInSlotsKey;
+import tools.refinery.viatra.runtime.emf.types.EStructuralFeatureInstancesKey;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.scopes.IStorageBackend;
+import tools.refinery.viatra.runtime.matchers.scopes.SimpleRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.DisjointUnionTable;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.ITableWriterBinary;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.ITableWriterUnary;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+/**
+ * Simple EMF-specific demo tabular index host. 
+ * 
+ * <p> Usage: <ul>
+ * <li> First, instantiate index host with given Ecore metamodel packages
+ * <li> To emulate an EMF instance model, write arbitrary content into the tables using {@link #getTableDirectInstances(EClassifier)} and {@link #getTableFeatureSlots(EStructuralFeature)}.
+ * <li> Initialize and evaluate regular EMF-based Viatra queries on the scope provided by {@link #getScope()}, as you would on an {@link EMFScope}. 
+ * <ul> 
+ * 
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @author Gabor Bergmann
+ * @since 2.1
+ */
+public class EcoreIndexHost extends TabularIndexHost {
+        
+        public EcoreIndexHost(IStorageBackend storage, EPackage... packages) {
+                super(storage, new SimpleRuntimeContext(EMFQueryMetaContext.DEFAULT_SURROGATE));
+                
+                initTables(packages);
+        }
+        
+        @Override
+    protected boolean isQueryScopeEmulated(Class<? extends QueryScope> queryScopeClass) {
+        return EMFScope.class.equals(queryScopeClass);
+    }
+        
+        private Map<EClassifier, ITableWriterUnary.Table<Object>> tableDirectInstances = CollectionsFactory.createMap();
+        private Map<EClass, DisjointUnionTable> tableTransitiveInstances = CollectionsFactory.createMap();
+        private Map<EStructuralFeature, ITableWriterBinary.Table<Object, Object>> tableFeatures = CollectionsFactory.createMap();
+        
+        private void initTables(EPackage[] packages) {
+                
+                // create instance tables first
+                for (EPackage ePackage : packages) {
+                        for (EClassifier eClassifier : ePackage.getEClassifiers()) {
+                                boolean unique;
+                                IInputKey classifierKey;
+                                if (eClassifier instanceof EClass) {
+                                        EClass eClass = (EClass) eClassifier;
+                                        // create transitive instances table
+                                        IInputKey transitiveKey = new EClassTransitiveInstancesKey(eClass);
+                                        DisjointUnionTable transitiveTable = registerNewTable(new DisjointUnionTable(transitiveKey, runtimeContext));
+                                        tableTransitiveInstances.put(eClass, transitiveTable);
+                                        
+                                        // process feature tables 
+                                        for (EStructuralFeature feature : eClass.getEStructuralFeatures()) {
+                                                IInputKey featureKey = new EStructuralFeatureInstancesKey(feature);
+                                                ITableWriterBinary.Table<Object, Object> featureTable = newBinaryInputTable(featureKey, feature.isUnique());
+                                                tableFeatures.put(feature, featureTable);
+                                        }
+                                        
+                                        // direct instance table
+                                        unique = true;
+                                        classifierKey = new EClassExactInstancesKey(eClass);
+                                } else { // datatype
+                                        unique = false;
+                                        classifierKey = new EDataTypeInSlotsKey((EDataType) eClassifier);
+                                }
+                                ITableWriterUnary.Table<Object> directTable = newUnaryInputTable(classifierKey, unique);
+                                tableDirectInstances.put(eClassifier, directTable);
+                        }
+                }
+                
+                // global implicit supertype EObject is always available as a transitive table
+                EClass eObjectClass = EcorePackage.eINSTANCE.getEObject();
+                DisjointUnionTable eObjectAllInstancesTable = tableTransitiveInstances.get(eObjectClass);
+                if (eObjectAllInstancesTable == null) { // is it already added?
+                        IInputKey transitiveKey = new EClassTransitiveInstancesKey(eObjectClass);
+                        eObjectAllInstancesTable = registerNewTable(new DisjointUnionTable(transitiveKey, runtimeContext));
+                        tableTransitiveInstances.put(eObjectClass, eObjectAllInstancesTable);
+                        
+                        boolean unique = true;
+                        IInputKey classifierKey = new EClassExactInstancesKey(eObjectClass);
+                        ITableWriterUnary.Table<Object> directTable = newUnaryInputTable(classifierKey, unique);
+                        tableDirectInstances.put(eObjectClass, directTable);
+                }
+                
+                // set up disjoint unoin tables
+                for (Entry<EClass, DisjointUnionTable> entry : tableTransitiveInstances.entrySet()) {
+                        EClass eClass = entry.getKey();
+                        ITableWriterUnary.Table<Object> directTable = tableDirectInstances.get(eClass);
+                        
+                        // the direct type itself is a child
+                        entry.getValue().addChildTable(directTable);
+                        
+                        // connect supertypes
+                        for (EClass superClass : eClass.getEAllSuperTypes()) {
+                                DisjointUnionTable transitiveTable = tableTransitiveInstances.get(superClass);
+                                if (transitiveTable == null) {
+                                    throw new IllegalStateException(
+                                            String.format("No index table found for EClass %s, supertype of %s",
+                                    superClass.getName(), eClass.getName())
+                    );
+                }
+                                transitiveTable.addChildTable(directTable);
+                        }
+                        // global implicit supertype
+                        if (!eClass.equals(eObjectClass)) {
+                                eObjectAllInstancesTable.addChildTable(directTable);
+                        }
+                                
+                }
+                
+        }
+        
+        public ITableWriterUnary.Table<Object> getTableDirectInstances(EClassifier classifier) {
+                return tableDirectInstances.get(classifier);
+        }
+        public ITableWriterBinary.Table<Object, Object> getTableFeatureSlots(EStructuralFeature feature) {
+                return tableFeatures.get(feature);
+        }
+        
+    public Set<Entry<EClassifier, ITableWriterUnary.Table<Object>>> getAllCurrentTablesDirectInstances() {
+        return Collections.unmodifiableSet(tableDirectInstances.entrySet());
+    }
+    public Set<Entry<EStructuralFeature, ITableWriterBinary.Table<Object, Object>>> getAllCurrentTablesFeatures() {
+        return Collections.unmodifiableSet(tableFeatures.entrySet());
+    }
+        
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/tabular/TabularEngineContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/tabular/TabularEngineContext.java
new file mode 100644
index 00000000..ee33d3bc
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/tabular/TabularEngineContext.java
@@ -0,0 +1,107 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.tabular;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.scope.*;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+import java.util.concurrent.Callable;
+/**
+ * @author Gabor Bergmann
+ * 
+ * @since 2.1
+ */
+class TabularEngineContext implements IEngineContext, IBaseIndex {
+        private TabularIndexHost indexHost;
+        private ViatraQueryEngine engine;
+        private Logger logger;
+        
+        private List<IIndexingErrorListener> errorListeners = CollectionsFactory.createObserverList();
+        public TabularEngineContext(TabularIndexHost server, ViatraQueryEngine engine,
+                        IIndexingErrorListener errorListener, Logger logger) {
+                                this.indexHost = server;
+                                this.engine = engine;
+                                this.logger = logger;
+                                
+                                this.addIndexingErrorListener(errorListener);
+        }
+        @Override
+        public IBaseIndex getBaseIndex() {
+                return this;
+        }
+        @Override
+        public void dispose() {
+                // NOP, server lifecycle not controlled by engine
+        }
+        @Override
+        public IQueryRuntimeContext getQueryRuntimeContext() {
+                return indexHost.getRuntimeContext();
+        }
+        @Override
+        public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException {
+                try {
+                        return callable.call();
+                } catch (Exception e) {
+                        throw new InvocationTargetException(e);
+                }
+        }
+        @Override
+        public void addBaseIndexChangeListener(ViatraBaseIndexChangeListener listener) {
+                // TODO no notifications yet
+        }
+        @Override
+        public void removeBaseIndexChangeListener(ViatraBaseIndexChangeListener listener) {
+                // TODO no notifications yet
+        }
+        @Override
+        public boolean addInstanceObserver(IInstanceObserver observer, Object observedObject) {
+                // TODO no notifications yet
+                return true;
+        }
+        @Override
+        public boolean removeInstanceObserver(IInstanceObserver observer, Object observedObject) {
+                // TODO no notifications yet
+                return true;
+        }
+        @Override
+        public void resampleDerivedFeatures() {
+                throw new UnsupportedOperationException();
+        }
+        @Override
+        public boolean addIndexingErrorListener(IIndexingErrorListener listener) {
+                return errorListeners.add(listener);
+        }
+        @Override
+        public boolean removeIndexingErrorListener(IIndexingErrorListener listener) {
+                return errorListeners.remove(listener);
+        }
+        
+        
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/tabular/TabularIndexHost.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/tabular/TabularIndexHost.java
new file mode 100644
index 00000000..6f2a1f5f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/tabular/TabularIndexHost.java
@@ -0,0 +1,145 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.tabular;
+import tools.refinery.viatra.runtime.api.ViatraQueryEngine;
+import tools.refinery.viatra.runtime.api.scope.IEngineContext;
+import tools.refinery.viatra.runtime.api.scope.IIndexingErrorListener;
+import tools.refinery.viatra.runtime.api.scope.QueryScope;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.scopes.IStorageBackend;
+import tools.refinery.viatra.runtime.matchers.scopes.TabularRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.IIndexTable;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.ITableWriterBinary;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.ITableWriterUnary;
+/**
+ * Simple tabular index host. 
+ * 
+ * Unlike traditional Viatra instances initialized on a model, 
+ *  this index host can be initialized and then queried, 
+ *  while its queriable "contents" (base relations) can be separately written using table writer API. 
+ *  
+ * <p> Deriving classes are responsible for setting up the tables of this index and providing the writer API to clients.
+ *  For the former, use {@link #newUnaryInputTable(IInputKey, boolean)}, 
+ *  {@link #newBinaryInputTable(IInputKey, boolean)} to create input tables, 
+ *  or {@link #registerNewTable(IIndexTable)} to register manually created derived tables. 
+ *  Instantiate such tables with {@link #runtimeContext} as their table context.
+ *  
+ * 
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @see EcoreIndexHost EcoreIndexHost for EMF-specific example usage.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.1
+ */
+public abstract class TabularIndexHost {
+    
+    private final IStorageBackend storage;
+    protected final TabularRuntimeContext runtimeContext;
+    protected final TabularIndexScope scope = new TabularIndexScope();
+    public TabularIndexHost(IStorageBackend storage, TabularRuntimeContext runtimeContext) {
+        this.storage = storage;
+        this.runtimeContext = runtimeContext;
+    }
+    public TabularRuntimeContext getRuntimeContext() {
+        return runtimeContext;
+    }
+    public TabularIndexScope getScope() {
+        return scope;
+    }
+    
+    /**
+     * @return true if this index host aims to serve queries that have a scope of the given type
+     */
+    protected abstract boolean isQueryScopeEmulated(Class<? extends QueryScope> queryScopeClass);
+    
+    
+    /**
+     * Marks the beginning of an update transaction.
+     * In transaction mode, index table updates may be temporarily delayed for better performance. 
+     * Stateful query backends will not update their results during the index update transaction. (TODO actually achieve this)
+     */
+    public void startUpdateTransaction() {
+        storage.startTransaction();
+    }
+    /**
+     * Marks the end of an update transaction.
+     * Any updates to index tables that were delayed during the transaction must now be flushed. 
+     * Afterwards, stateful query backends will update their results. (TODO actually achieve this)
+     */
+    public void finishUpdateTransaction() {
+        storage.finishTransaction();
+    }
+    
+    /**
+     * To be called by deriving class. Creates and registers a new unary input table.
+     */
+    protected ITableWriterUnary.Table<Object> newUnaryInputTable(IInputKey key, boolean unique) {
+        return registerNewTable(storage.createUnaryTable(key, runtimeContext, unique));
+    }
+    /**
+     * To be called by deriving class. Creates and registers a new binary input table.
+     */
+    protected ITableWriterBinary.Table<Object,Object> newBinaryInputTable(IInputKey key, boolean unique) {
+        return registerNewTable(storage.createBinaryTable(key, runtimeContext, unique));
+    }
+    /**
+     * To be called by deriving class. Registers the given freshly created table and also returns it for convenience.
+     */
+    protected <Table extends IIndexTable> Table registerNewTable(Table newTable) {
+        runtimeContext.registerIndexTable(newTable);
+        return newTable;
+    }
+    /**
+     * A scope describing queries evaluated against tzhis index host.
+     * @author Gabor Bergmann
+     *
+     */
+    public class TabularIndexScope extends QueryScope {
+        
+        public TabularIndexHost getIndexHost() {
+            return TabularIndexHost.this;
+        }
+        
+        @Override
+        public int hashCode() {
+            return getIndexHost().hashCode();
+        }
+        
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof TabularIndexScope)
+                return getIndexHost().equals(((TabularIndexScope) obj).getIndexHost());
+            return false;
+        }
+        
+        @Override
+        public boolean isCompatibleWithQueryScope(Class<? extends QueryScope> queryScopeClass) {
+            return isQueryScopeEmulated(queryScopeClass) || super.isCompatibleWithQueryScope(queryScopeClass);
+        }
+        
+        @Override
+        protected IEngineContext createEngineContext(ViatraQueryEngine engine, IIndexingErrorListener errorListener, org.apache.log4j.Logger logger) {
+            return new TabularEngineContext(getIndexHost(), engine, errorListener, logger);
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/util/ViatraQueryLoggingUtil.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/util/ViatraQueryLoggingUtil.java
new file mode 100644
index 00000000..229801f8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/util/ViatraQueryLoggingUtil.java
@@ -0,0 +1,72 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.util;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+/**
+ * Centralized logger of the VIATRA Query runtime.
+ * @author Bergmann Gabor
+ *
+ */
+public class ViatraQueryLoggingUtil {
+    private ViatraQueryLoggingUtil() {/*Utility class constructor*/}
+    private static Logger externalLogger;
+    public static void setExternalLogger(Logger externalLogger) {
+        Preconditions.checkArgument(externalLogger != null, "Must not set up null logger");
+        ViatraQueryLoggingUtil.externalLogger = externalLogger;
+    }
+    /**
+     * Provides a static default logger.
+     */
+    public static Logger getDefaultLogger() {
+        if (defaultRuntimeLogger == null) {
+            Logger parentLogger = externalLogger;
+            if (parentLogger == null) {
+                defaultRuntimeLogger = Logger.getLogger("org.eclipse.viatra");
+            } else {
+                defaultRuntimeLogger = Logger.getLogger(parentLogger.getName() + ".runtime");
+            }
+            if (defaultRuntimeLogger == null)
+                throw new AssertionError("Configuration error: unable to create default VIATRA Query runtime logger.");
+        }
+        return defaultRuntimeLogger;
+    }
+    private static String getLoggerClassname(Class<?> clazz) {
+        return clazz.getName().startsWith(getDefaultLogger().getName())
+                ? clazz.getName()
+                : getDefaultLogger().getName() + "." + clazz.getName();
+    }
+    /**
+     * Provides a class-specific logger that also stores the global logger settings of the VIATRA Query runtime
+     * @param clazz
+     */
+    public static Logger getLogger(Class<?> clazz) {
+        return Logger.getLogger(getLoggerClassname(clazz));
+    }
+    /**
+     * Provides a named logger that also stores the global logger settings of the VIATRA Query runtime
+     * @param clazz
+     * @param name a non-empty name to append to the class names
+     * @since 2.5
+     */
+    public static Logger getLogger(Class<?> clazz, String name) {
+        return Logger.getLogger(getLoggerClassname(clazz) + '.' + name);
+    }
+    private static Logger defaultRuntimeLogger;
+}
author	Kristóf Marussy <kristof@marussy.com>	2023-08-19 02:31:57 +0200
committer	Kristóf Marussy <kristof@marussy.com>	2023-08-19 02:31:57 +0200
commit	9adbb3d49899a87b3026c11cb4ba3ff77f4fb75b (patch)
tree	fad77963c1dc9028b0a767ac3ad69a174c8eb8c6 /subprojects/viatra-runtime
parent	feat: predicate semantics (diff)
download	refinery-9adbb3d49899a87b3026c11cb4ba3ff77f4fb75b.tar.gz refinery-9adbb3d49899a87b3026c11cb4ba3ff77f4fb75b.tar.zst refinery-9adbb3d49899a87b3026c11cb4ba3ff77f4fb75b.zip