diff --git a/runtime/vm/compiler/backend/type_propagator.cc b/runtime/vm/compiler/backend/type_propagator.cc
index e4f7d2e..81b5e09 100644
--- a/runtime/vm/compiler/backend/type_propagator.cc
+++ b/runtime/vm/compiler/backend/type_propagator.cc
@@ -130,7 +130,7 @@
   // can contain [AssertAssignableInstr]s and we therefore enable this
   // optimization.
   Isolate* isolate = Isolate::Current();
-  if (isolate->type_checks() || isolate->strong()) {
+  if (isolate->argument_type_checks()) {
     StrengthenAsserts(block);
   }
 
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
index 588c85a..e690459 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
@@ -956,6 +956,10 @@
 
 Fragment StreamingFlowGraphBuilder::BuildArgumentTypeChecks(
     TypeChecksToBuild mode) {
+  if (FLAG_omit_strong_type_checks) {
+    return Fragment();
+  }
+
   FunctionNodeHelper function_node_helper(this);
   function_node_helper.SetNext(FunctionNodeHelper::kTypeParameters);
   const Function& dart_function = parsed_function()->function();
@@ -2717,7 +2721,8 @@
     const intptr_t kNumArgsChecked = 1;
 
     const String* mangled_name = &setter_name;
-    if (!FLAG_precompiled_mode && I->strong() && H.IsRoot(itarget_name)) {
+    if (!FLAG_precompiled_mode && I->strong() &&
+        !FLAG_omit_strong_type_checks && H.IsRoot(itarget_name)) {
       mangled_name = &String::ZoneHandle(
           Z, Function::CreateDynamicInvocationForwarderName(setter_name));
     }
@@ -3291,6 +3296,7 @@
     //     those cases require a dynamic invocation forwarder;
     //   * we assume that all closures are entered in a checked way.
     if (!FLAG_precompiled_mode && I->strong() &&
+        !FLAG_omit_strong_type_checks &&
         (name.raw() != Symbols::EqualOperator().raw()) &&
         (name.raw() != Symbols::Call().raw()) && H.IsRoot(itarget_name)) {
       mangled_name = &String::ZoneHandle(
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index 73d7c38..fa2d862 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -1593,6 +1593,9 @@
   if (dst_type.IsMalformed()) {
     return ThrowTypeError();
   }
+  if (FLAG_omit_strong_type_checks) {
+    return Fragment();
+  }
   if (!dst_type.IsDynamicType() && !dst_type.IsObjectType() &&
       !dst_type.IsVoidType()) {
     LocalVariable* top_of_stack = MakeTemporary();
@@ -1605,6 +1608,9 @@
 }
 
 Fragment FlowGraphBuilder::AssertBool(TokenPosition position) {
+  if (FLAG_omit_strong_type_checks) {
+    return Fragment();
+  }
   Value* value = Pop();
   AssertBooleanInstr* instr =
       new (Z) AssertBooleanInstr(position, value, GetNextDeoptId());
@@ -1616,6 +1622,10 @@
                                             const AbstractType& dst_type,
                                             const String& dst_name,
                                             AssertAssignableInstr::Kind kind) {
+  if (FLAG_omit_strong_type_checks) {
+    return Fragment();
+  }
+
   Fragment instructions;
   Value* value = Pop();
 
diff --git a/runtime/vm/compiler/jit/compiler.cc b/runtime/vm/compiler/jit/compiler.cc
index 9083339..be3018b 100644
--- a/runtime/vm/compiler/jit/compiler.cc
+++ b/runtime/vm/compiler/jit/compiler.cc
@@ -132,6 +132,18 @@
                     precompilation,
                     "Precompilation mode");
 
+static void UnsafeModeHandler(bool value) {
+  if (value) {
+    FLAG_omit_strong_type_checks = true;
+    FLAG_use_strong_mode_types = false;
+  }
+}
+
+DEFINE_FLAG_HANDLER(UnsafeModeHandler,
+                    experimental_unsafe_mode_use_at_your_own_risk,
+                    "Omit runtime strong mode type checks and disable "
+                    "optimizations based on types.");
+
 #ifndef DART_PRECOMPILED_RUNTIME
 
 bool UseKernelFrontEndFor(ParsedFunction* parsed_function) {
diff --git a/runtime/vm/flag_list.h b/runtime/vm/flag_list.h
index 670fd1a..40a8d28 100644
--- a/runtime/vm/flag_list.h
+++ b/runtime/vm/flag_list.h
@@ -122,6 +122,7 @@
     "Max size of new gen semi space in MB")                                    \
   P(new_gen_semi_initial_size, int, (kWordSize <= 4) ? 1 : 2,                  \
     "Initial size of new gen semi space in MB")                                \
+  P(omit_strong_type_checks, bool, false, "Omit strong mode type checks.")     \
   P(optimization_counter_threshold, int, 30000,                                \
     "Function's usage-counter value before it is optimized, -1 means never")   \
   P(old_gen_heap_size, int, kDefaultMaxOldGenHeapSize,                         \
diff --git a/runtime/vm/isolate.h b/runtime/vm/isolate.h
index 974c447..318ed36 100644
--- a/runtime/vm/isolate.h
+++ b/runtime/vm/isolate.h
@@ -749,7 +749,9 @@
 
   // Convenience flag tester indicating whether incoming function arguments
   // should be type checked.
-  bool argument_type_checks() { return strong() || type_checks(); }
+  bool argument_type_checks() {
+    return (strong() && !FLAG_omit_strong_type_checks) || type_checks();
+  }
 
   static void KillAllIsolates(LibMsgId msg_id);
   static void KillIfExists(Isolate* isolate, LibMsgId msg_id);
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 3a1b5cb..eede837 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -2428,6 +2428,9 @@
 
   bool NeedsArgumentTypeChecks(Isolate* I) const {
     if (I->strong()) {
+      if (FLAG_omit_strong_type_checks) {
+        return false;
+      }
       return IsNonImplicitClosureFunction() ||
              !(is_static() || (kind() == RawFunction::kConstructor));
     }
diff --git a/runtime/vm/scopes.h b/runtime/vm/scopes.h
index 15548dc..1383695 100644
--- a/runtime/vm/scopes.h
+++ b/runtime/vm/scopes.h
@@ -129,7 +129,9 @@
 
   // Returns true if this local variable represents a parameter that needs type
   // check when we enter the function.
-  bool needs_type_check() const { return type_check_mode_ == kDoTypeCheck; }
+  bool needs_type_check() const {
+    return (type_check_mode_ == kDoTypeCheck) && !FLAG_omit_strong_type_checks;
+  }
 
   // Returns true if this local variable represents a parameter which type is
   // guaranteed by the caller.