93 files changed, 10042 insertions, 0 deletions
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;
+}