diff --git a/.gitignore b/.gitignore
index c2acc737a..bf94681b7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,4 +15,10 @@ obj/
 bin/
 .svn/
 
-**/.vscode/
\ No newline at end of file
+**/.vscode/
+
+.project
+.DS_Store
+.settings
+
+build-artifacts/
\ No newline at end of file
diff --git a/runtime/src/main/java/com/tns/AppConfig.java b/runtime/src/main/java/com/tns/AppConfig.java
index 3dad082f6..3c342fac7 100644
--- a/runtime/src/main/java/com/tns/AppConfig.java
+++ b/runtime/src/main/java/com/tns/AppConfig.java
@@ -1,14 +1,12 @@
 package com.tns;
 
 import java.io.File;
-
 import org.json.JSONObject;
-
 import android.os.Build;
 import android.util.Log;
 
 class AppConfig {
-    private enum KnownKeys {
+    protected enum KnownKeys {
         V8FlagsKey("v8Flags", "--expose_gc"),
         CodeCacheKey("codeCache", false),
         HeapSnapshotScriptKey("heapSnapshotScript", ""),
@@ -17,19 +15,8 @@ private enum KnownKeys {
         GcThrottleTime("gcThrottleTime", 0),
         MemoryCheckInterval("memoryCheckInterval", 0),
         FreeMemoryRatio("freeMemoryRatio", 0.0),
-        Profiling("profiling", "");
-
-        public static final KnownKeys[] asArray = {
-            V8FlagsKey,
-            CodeCacheKey,
-            HeapSnapshotScriptKey,
-            SnapshotFile,
-            ProfilerOutputDirKey,
-            GcThrottleTime,
-            MemoryCheckInterval,
-            FreeMemoryRatio,
-            Profiling
-        };
+        Profiling("profiling", ""),
+        MarkingMode("markingMode", com.tns.MarkingMode.full);
 
         private final String name;
         private final Object defaultValue;
@@ -42,19 +29,9 @@ private enum KnownKeys {
         public String getName() {
             return name;
         }
-
         public Object getDefaultValue() {
             return defaultValue;
         }
-
-        int getIndex() {
-            for (int i=0; i<asArray.length; i++) {
-                if (asArray[i] == this) {
-                    return i;
-                }
-            }
-            return -1;
-        }
     }
 
     private final static String AndroidKey = "android";
@@ -75,19 +52,19 @@ public AppConfig(File appDir) {
             if (rootObject != null) {
                 if (rootObject.has(KnownKeys.Profiling.getName())) {
                     String profiling = rootObject.getString(KnownKeys.Profiling.getName());
-                    values[KnownKeys.Profiling.getIndex()] = profiling;
+                    values[KnownKeys.Profiling.ordinal()] = profiling;
                 }
                 if (rootObject.has(AndroidKey)) {
                     JSONObject androidObject = rootObject.getJSONObject(AndroidKey);
                     if (androidObject.has(KnownKeys.V8FlagsKey.getName())) {
-                        values[KnownKeys.V8FlagsKey.getIndex()] = androidObject.getString(KnownKeys.V8FlagsKey.getName());
+                        values[KnownKeys.V8FlagsKey.ordinal()] = androidObject.getString(KnownKeys.V8FlagsKey.getName());
                     }
                     if (androidObject.has(KnownKeys.CodeCacheKey.getName())) {
-                        values[KnownKeys.CodeCacheKey.getIndex()] = androidObject.getBoolean(KnownKeys.CodeCacheKey.getName());
+                        values[KnownKeys.CodeCacheKey.ordinal()] = androidObject.getBoolean(KnownKeys.CodeCacheKey.getName());
                     }
                     if (androidObject.has(KnownKeys.HeapSnapshotScriptKey.getName())) {
                         String value = androidObject.getString(KnownKeys.HeapSnapshotScriptKey.getName());
-                        values[KnownKeys.HeapSnapshotScriptKey.getIndex()] = FileSystem.resolveRelativePath(appDir.getPath(), value, appDir + "/app/");
+                        values[KnownKeys.HeapSnapshotScriptKey.ordinal()] = FileSystem.resolveRelativePath(appDir.getPath(), value, appDir + "/app/");
                     }
                     if (androidObject.has(HeapSnapshotBlobKey)) {
                         String value = androidObject.getString(HeapSnapshotBlobKey);
@@ -96,20 +73,30 @@ public AppConfig(File appDir) {
                         if (dir.exists() && dir.isDirectory()) {
                             // this path is expected to be a directory, containing three sub-directories: armeabi-v7a, x86 and arm64-v8a
                             path = path + "/" + Build.CPU_ABI + "/" + KnownKeys.SnapshotFile.getName();
-                            values[KnownKeys.SnapshotFile.getIndex()] = path;
+                            values[KnownKeys.SnapshotFile.ordinal()] = path;
                         }
                     }
                     if (androidObject.has(KnownKeys.ProfilerOutputDirKey.getName())) {
-                        values[KnownKeys.ProfilerOutputDirKey.getIndex()] = androidObject.getString(KnownKeys.ProfilerOutputDirKey.getName());
+                        values[KnownKeys.ProfilerOutputDirKey.ordinal()] = androidObject.getString(KnownKeys.ProfilerOutputDirKey.getName());
                     }
                     if (androidObject.has(KnownKeys.GcThrottleTime.getName())) {
-                        values[KnownKeys.GcThrottleTime.getIndex()] = androidObject.getInt(KnownKeys.GcThrottleTime.getName());
+                        values[KnownKeys.GcThrottleTime.ordinal()] = androidObject.getInt(KnownKeys.GcThrottleTime.getName());
                     }
                     if (androidObject.has(KnownKeys.MemoryCheckInterval.getName())) {
-                        values[KnownKeys.MemoryCheckInterval.getIndex()] = androidObject.getInt(KnownKeys.MemoryCheckInterval.getName());
+                        values[KnownKeys.MemoryCheckInterval.ordinal()] = androidObject.getInt(KnownKeys.MemoryCheckInterval.getName());
                     }
                     if (androidObject.has(KnownKeys.FreeMemoryRatio.getName())) {
-                        values[KnownKeys.FreeMemoryRatio.getIndex()] = androidObject.getDouble(KnownKeys.FreeMemoryRatio.getName());
+                        values[KnownKeys.FreeMemoryRatio.ordinal()] = androidObject.getDouble(KnownKeys.FreeMemoryRatio.getName());
+                    }
+                    if (androidObject.has(KnownKeys.MarkingMode.getName())) {
+                        try {
+                            String markingModeString = androidObject.getString(KnownKeys.MarkingMode.getName());
+                            MarkingMode markingMode = MarkingMode.valueOf(markingModeString);
+                            values[KnownKeys.MarkingMode.ordinal()] = markingMode;
+                        } catch(Exception e) {
+                            e.printStackTrace();
+                            Log.v("JS", "Failed to parse marking mode. The default " + ((MarkingMode)KnownKeys.MarkingMode.getDefaultValue()).name() + " will be used.");
+                        }
                     }
                 }
             }
@@ -123,27 +110,28 @@ public Object[] getAsArray() {
     }
 
     private static Object[] makeDefaultOptions() {
-        Object[] result = new Object[KnownKeys.asArray.length];
-        int index = 0;
-        for (KnownKeys key: KnownKeys.asArray) {
-            result[index++] = key.getDefaultValue();
+        Object[] result = new Object[KnownKeys.values().length];
+        for (KnownKeys key: KnownKeys.values()) {
+            result[key.ordinal()] = key.getDefaultValue();
         }
         return result;
     }
 
     public int getGcThrottleTime() {
-        return (int)values[KnownKeys.GcThrottleTime.getIndex()];
+        return (int)values[KnownKeys.GcThrottleTime.ordinal()];
     }
 
     public int getMemoryCheckInterval() {
-        return (int)values[KnownKeys.MemoryCheckInterval.getIndex()];
+        return (int)values[KnownKeys.MemoryCheckInterval.ordinal()];
     }
 
     public double getFreeMemoryRatio() {
-        return (double)values[KnownKeys.FreeMemoryRatio.getIndex()];
+        return (double)values[KnownKeys.FreeMemoryRatio.ordinal()];
     }
 
     public String getProfilingMode() {
-        return (String)values[KnownKeys.Profiling.getIndex()];
+        return (String)values[KnownKeys.Profiling.ordinal()];
     }
+
+    public MarkingMode getMarkingMode() { return (MarkingMode)values[KnownKeys.MarkingMode.ordinal()]; }
 }
diff --git a/runtime/src/main/java/com/tns/MarkingMode.java b/runtime/src/main/java/com/tns/MarkingMode.java
new file mode 100644
index 000000000..224a87a91
--- /dev/null
+++ b/runtime/src/main/java/com/tns/MarkingMode.java
@@ -0,0 +1,9 @@
+package com.tns;
+
+/**
+ * Created by cankov on 24/08/2017.
+ */
+enum MarkingMode {
+    full,
+    none
+}
diff --git a/runtime/src/main/java/com/tns/Runtime.java b/runtime/src/main/java/com/tns/Runtime.java
index d7fe54dc1..e4651ef67 100644
--- a/runtime/src/main/java/com/tns/Runtime.java
+++ b/runtime/src/main/java/com/tns/Runtime.java
@@ -202,9 +202,17 @@ public DynamicConfiguration getDynamicConfig() {
         return dynamicConfig;
     }
 
+    @RuntimeCallable
+    public int getMarkingModeOrdinal() {
+        if (staticConfiguration != null && staticConfiguration.appConfig != null) {
+            return staticConfiguration.appConfig.getMarkingMode().ordinal();
+        } else {
+            return ((MarkingMode)AppConfig.KnownKeys.MarkingMode.getDefaultValue()).ordinal();
+        }
+    }
+
     public static boolean isInitialized() {
         Runtime runtime = Runtime.getCurrentRuntime();
-
         return (runtime != null) ? runtime.isInitializedImpl() : false;
     }
 
@@ -806,6 +814,38 @@ private void makeInstanceWeak(ByteBuffer buff, int length, boolean keepAsWeak) {
         }
     }
 
+    @RuntimeCallable
+    private boolean makeInstanceWeakAndCheckIfAlive(int javaObjectID) {
+        if (logger.isEnabled()) {
+            logger.write("makeInstanceWeakAndCheckIfAlive instance " + javaObjectID);
+        }
+        Object instance = strongInstances.get(javaObjectID);
+        if (instance == null) {
+            WeakReference<Object> ref = weakInstances.get(javaObjectID);
+            if (ref == null) {
+                return false;
+            } else {
+                instance = ref.get();
+                if (instance == null) {
+                    // The Java was moved from strong to weak, and then the Java instance was collected.
+                    weakInstances.remove(javaObjectID);
+                    weakJavaObjectToID.remove(Integer.valueOf(javaObjectID));
+                    return false;
+                } else {
+                    return true;
+                }
+            }
+        } else {
+            strongInstances.delete(javaObjectID);
+            strongJavaObjectToID.remove(instance);
+
+            weakJavaObjectToID.put(instance, Integer.valueOf(javaObjectID));
+            weakInstances.put(javaObjectID, new WeakReference<Object>(instance));
+
+            return true;
+        }
+    }
+
     @RuntimeCallable
     private void checkWeakObjectAreAlive(ByteBuffer input, ByteBuffer output, int length) {
         input.position(0);
diff --git a/runtime/src/main/jni/ObjectManager.cpp b/runtime/src/main/jni/ObjectManager.cpp
index 96a0a19ad..774917104 100644
--- a/runtime/src/main/jni/ObjectManager.cpp
+++ b/runtime/src/main/jni/ObjectManager.cpp
@@ -17,8 +17,13 @@ using namespace v8;
 using namespace std;
 using namespace tns;
 
-ObjectManager::ObjectManager(jobject javaRuntimeObject)
-    : m_javaRuntimeObject(javaRuntimeObject), m_env(JEnv()), m_numberOfGC(0), m_currentObjectId(0), m_cache(NewWeakGlobalRefCallback, DeleteWeakGlobalRefCallback, 1000, this) {
+ObjectManager::ObjectManager(jobject javaRuntimeObject) :
+        m_javaRuntimeObject(javaRuntimeObject),
+        m_env(JEnv()),
+        m_numberOfGC(0),
+        m_currentObjectId(0),
+        m_cache(NewWeakGlobalRefCallback, DeleteWeakGlobalRefCallback, 1000, this) {
+
     auto runtimeClass = m_env.FindClass("com/tns/Runtime");
     assert(runtimeClass != nullptr);
 
@@ -31,6 +36,9 @@ ObjectManager::ObjectManager(jobject javaRuntimeObject)
     MAKE_INSTANCE_WEAK_BATCH_METHOD_ID = m_env.GetMethodID(runtimeClass, "makeInstanceWeak", "(Ljava/nio/ByteBuffer;IZ)V");
     assert(MAKE_INSTANCE_WEAK_BATCH_METHOD_ID != nullptr);
 
+    MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID = m_env.GetMethodID(runtimeClass, "makeInstanceWeakAndCheckIfAlive", "(I)Z");
+    assert(MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID != nullptr);
+
     CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID = m_env.GetMethodID(runtimeClass, "checkWeakObjectAreAlive", "(Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;I)V");
     assert(CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID != nullptr);
 
@@ -45,6 +53,10 @@ ObjectManager::ObjectManager(jobject javaRuntimeObject)
 
     auto useGlobalRefs = m_env.CallStaticBooleanMethod(runtimeClass, useGlobalRefsMethodID);
     m_useGlobalRefs = useGlobalRefs == JNI_TRUE;
+
+    auto getMarkingModeOrdinalMethodID = m_env.GetMethodID(runtimeClass, "getMarkingModeOrdinal", "()I");
+    jint markingMode = m_env.CallIntMethod(m_javaRuntimeObject, getMarkingModeOrdinalMethodID);
+    m_markingMode = static_cast<JavaScriptMarkingMode>(markingMode);
 }
 
 void ObjectManager::SetInstanceIsolate(Isolate* isolate) {
@@ -57,8 +69,10 @@ void ObjectManager::Init(Isolate* isolate) {
     auto jsWrapperFunc = jsWrapperFuncTemplate->GetFunction();
     m_poJsWrapperFunc = new Persistent<Function>(isolate, jsWrapperFunc);
 
-    isolate->AddGCPrologueCallback(ObjectManager::OnGcStartedStatic, kGCTypeAll);
-    isolate->AddGCEpilogueCallback(ObjectManager::OnGcFinishedStatic, kGCTypeAll);
+    if (m_markingMode != JavaScriptMarkingMode::None) {
+        isolate->AddGCPrologueCallback(ObjectManager::OnGcStartedStatic, kGCTypeAll);
+        isolate->AddGCEpilogueCallback(ObjectManager::OnGcFinishedStatic, kGCTypeAll);
+    }
 }
 
 
@@ -80,32 +94,35 @@ JniLocalRef ObjectManager::GetJavaObjectByJsObject(const Local<Object>& object)
 
 ObjectManager::JSInstanceInfo* ObjectManager::GetJSInstanceInfo(const Local<Object>& object) {
     JSInstanceInfo* jsInstanceInfo = nullptr;
+    if (IsJsRuntimeObject(object)) {
+        return GetJSInstanceInfoFromRuntimeObject(object);
+    }
+    return nullptr;
+}
 
-    auto isolate = m_isolate;
-    HandleScope handleScope(isolate);
+ObjectManager::JSInstanceInfo* ObjectManager::GetJSInstanceInfoFromRuntimeObject(const Local<Object>& object) {
+    HandleScope handleScope(m_isolate);
 
-    if (IsJsRuntimeObject(object)) {
-        const int jsInfoIdx = static_cast<int>(MetadataNodeKeys::JsInfo);
-        auto jsInfo = object->GetInternalField(jsInfoIdx);
-        if (jsInfo->IsUndefined()) {
-            //Typescript object layout has an object instance as child of the actual registered instance. checking for that
-            auto prototypeObject = object->GetPrototype().As<Object>();
-
-            if (!prototypeObject.IsEmpty() && prototypeObject->IsObject()) {
-                DEBUG_WRITE("GetJSInstanceInfo: need to check prototype :%d", prototypeObject->GetIdentityHash());
-                if (IsJsRuntimeObject(prototypeObject)) {
-                    jsInfo = prototypeObject->GetInternalField(jsInfoIdx);
-                }
+    const int jsInfoIdx = static_cast<int>(MetadataNodeKeys::JsInfo);
+    auto jsInfo = object->GetInternalField(jsInfoIdx);
+    if (jsInfo->IsUndefined()) {
+        //Typescript object layout has an object instance as child of the actual registered instance. checking for that
+        auto prototypeObject = object->GetPrototype().As<Object>();
+
+        if (!prototypeObject.IsEmpty() && prototypeObject->IsObject()) {
+            DEBUG_WRITE("GetJSInstanceInfo: need to check prototype :%d", prototypeObject->GetIdentityHash());
+            if (IsJsRuntimeObject(prototypeObject)) {
+                jsInfo = prototypeObject->GetInternalField(jsInfoIdx);
             }
         }
+    }
 
-        if (!jsInfo.IsEmpty() && jsInfo->IsExternal()) {
-            auto external = jsInfo.As<External>();
-            jsInstanceInfo = static_cast<JSInstanceInfo*>(external->Value());
-        }
+    if (!jsInfo.IsEmpty() && jsInfo->IsExternal()) {
+        auto external = jsInfo.As<External>();
+        return static_cast<JSInstanceInfo*>(external->Value());
     }
 
-    return jsInstanceInfo;
+    return nullptr;
 }
 
 bool ObjectManager::IsJsRuntimeObject(const v8::Local<v8::Object>& object) {
@@ -211,7 +228,11 @@ void ObjectManager::Link(const Local<Object>& object, uint32_t javaObjectID, jcl
     auto state = new ObjectWeakCallbackState(this, jsInstanceInfo, objectHandle);
 
     // subscribe for JS GC event
-    objectHandle->SetWeak(state, JSObjectWeakCallbackStatic, WeakCallbackType::kFinalizer);
+    if (m_markingMode == JavaScriptMarkingMode::None) {
+        objectHandle->SetWeak(state, JSObjectFinalizerStatic, WeakCallbackType::kFinalizer);
+    } else {
+        objectHandle->SetWeak(state, JSObjectWeakCallbackStatic, WeakCallbackType::kFinalizer);
+    }
 
     auto jsInfoIdx = static_cast<int>(MetadataNodeKeys::JsInfo);
 
@@ -263,6 +284,40 @@ void ObjectManager::JSObjectWeakCallbackStatic(const WeakCallbackInfo<ObjectWeak
     thisPtr->JSObjectWeakCallback(isolate, callbackState);
 }
 
+void ObjectManager::JSObjectFinalizerStatic(const WeakCallbackInfo<ObjectWeakCallbackState>& data) {
+    ObjectWeakCallbackState* callbackState = data.GetParameter();
+
+    ObjectManager* thisPtr = callbackState->thisPtr;
+
+    auto isolate = data.GetIsolate();
+
+    thisPtr->JSObjectFinalizer(isolate, callbackState);
+}
+
+void ObjectManager::JSObjectFinalizer(Isolate* isolate, ObjectWeakCallbackState* callbackState) {
+    HandleScope handleScope(m_isolate);
+    Persistent<Object>* po = callbackState->target;
+    auto jsInstanceInfo = GetJSInstanceInfoFromRuntimeObject(po->Get(m_isolate));
+
+    if (jsInstanceInfo == nullptr) {
+        po->Reset();
+        return;
+    }
+
+    auto javaObjectID = jsInstanceInfo->JavaObjectID;
+    jboolean isJavaInstanceAlive = m_env.CallBooleanMethod(m_javaRuntimeObject, MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID, javaObjectID);
+    if (isJavaInstanceAlive) {
+        // If the Java instance is alive, keep the JavaScript instance alive.
+        po->SetWeak(callbackState, JSObjectFinalizerStatic, WeakCallbackType::kFinalizer);
+    } else {
+        // If the Java instance is dead, this JavaScript instance can be let die.
+        delete jsInstanceInfo;
+        auto jsInfoIdx = static_cast<int>(MetadataNodeKeys::JsInfo);
+        po->Get(m_isolate)->SetInternalField(jsInfoIdx, Undefined(m_isolate));
+        po->Reset();
+    }
+}
+
 /*
  * When JS GC happens change state of the java counterpart to mirror state of JS object and REVIVE the JS object unconditionally
  * "Regular" js objects are pushed into the "regular objects" array
diff --git a/runtime/src/main/jni/ObjectManager.h b/runtime/src/main/jni/ObjectManager.h
index b9b0f3d00..41787a073 100644
--- a/runtime/src/main/jni/ObjectManager.h
+++ b/runtime/src/main/jni/ObjectManager.h
@@ -57,6 +57,21 @@ class ObjectManager {
             END
         };
 
+        /**
+         * Memory management modes. Keep the members in sync with the java/com/tns/MarkingMode.
+         */
+        enum JavaScriptMarkingMode {
+            /**
+             * For JavaScript instances with implementation objects that were marked for collection,
+             * MarkReachableObjects will scan the whole graph of reachable objects and keep strong reference to
+             * the Java instances of implementation objects.
+             */
+            Full,
+            /**
+             * Fully suppress the MarkReachableObjects.
+             */
+            None
+        };
 
     private:
 
@@ -128,6 +143,8 @@ class ObjectManager {
 
         JSInstanceInfo* GetJSInstanceInfo(const v8::Local<v8::Object>& object);
 
+        JSInstanceInfo* GetJSInstanceInfoFromRuntimeObject(const v8::Local<v8::Object>& object);
+
         void ReleaseJSInstance(v8::Persistent<v8::Object>* po, JSInstanceInfo* jsInstanceInfo);
 
         void ReleaseRegularObjects();
@@ -142,8 +159,12 @@ class ObjectManager {
 
         static void JSObjectWeakCallbackStatic(const v8::WeakCallbackInfo<ObjectWeakCallbackState>& data);
 
+        static void JSObjectFinalizerStatic(const v8::WeakCallbackInfo<ObjectWeakCallbackState>& data);
+
         void JSObjectWeakCallback(v8::Isolate* isolate, ObjectWeakCallbackState* callbackState);
 
+        void JSObjectFinalizer(v8::Isolate* isolate, ObjectWeakCallbackState* callbackState);
+
         bool HasImplObject(v8::Isolate* isolate, const v8::Local<v8::Object>& obj);
 
         void MarkReachableObjects(v8::Isolate* isolate, const v8::Local<v8::Object>& obj);
@@ -196,6 +217,8 @@ class ObjectManager {
 
         bool m_useGlobalRefs;
 
+        JavaScriptMarkingMode m_markingMode;
+
         jclass JAVA_LANG_CLASS;
 
         jmethodID GET_NAME_METHOD_ID;
@@ -206,6 +229,8 @@ class ObjectManager {
 
         jmethodID MAKE_INSTANCE_WEAK_BATCH_METHOD_ID;
 
+        jmethodID MAKE_INSTANCE_WEAK_AND_CHECK_IF_ALIVE_METHOD_ID;
+
         jmethodID CHECK_WEAK_OBJECTS_ARE_ALIVE_METHOD_ID;
 
         v8::Persistent<v8::Function>* m_poJsWrapperFunc;
diff --git a/test-app/app/src/main/assets/app/package.json b/test-app/app/src/main/assets/app/package.json
index 37d761fcb..a9e6c65c3 100644
--- a/test-app/app/src/main/assets/app/package.json
+++ b/test-app/app/src/main/assets/app/package.json
@@ -5,6 +5,7 @@
 		"profilerOutputDir": "",
 		"gcThrottleTime": 500,
 		"memoryCheckInterval": 10,
-		"freeMemoryRatio": 0.50
+		"freeMemoryRatio": 0.50,
+		"markingMode": "full"
 	}
 }
\ No newline at end of file