diff --git a/src/mono/mono/metadata/appdomain.c b/src/mono/mono/metadata/appdomain.c
index 318a7838a0d762..ec9d6d32ee01a1 100644
--- a/src/mono/mono/metadata/appdomain.c
+++ b/src/mono/mono/metadata/appdomain.c
@@ -188,15 +188,10 @@ create_domain_objects (MonoDomain *domain)
 	HANDLE_FUNCTION_ENTER ();
 	ERROR_DECL (error);
 
-	MonoDomain *old_domain = mono_domain_get ();
 	MonoStringHandle arg;
 	MonoVTable *string_vt;
 	MonoClassField *string_empty_fld;
 
-	if (domain != old_domain) {
-		mono_domain_set_internal_with_options (domain, FALSE);
-	}
-
 	/*
 	 * Initialize String.Empty. This enables the removal of
 	 * the static cctor of the String class.
@@ -237,9 +232,6 @@ create_domain_objects (MonoDomain *domain)
 	domain->ephemeron_tombstone = MONO_HANDLE_RAW (mono_object_new_handle (domain, mono_defaults.object_class, error));
 	mono_error_assert_ok (error);
 
-	if (domain != old_domain)
-		mono_domain_set_internal_with_options (old_domain, FALSE);
-
 	/* 
 	 * This class is used during exception handling, so initialize it here, to prevent
 	 * stack overflows while handling stack overflows.
@@ -431,34 +423,42 @@ mono_check_corlib_version_internal (void)
 void
 mono_context_init (MonoDomain *domain)
 {
-	ERROR_DECL (error);
-	mono_context_init_checked (domain, error);
-	mono_error_cleanup (error);
+	g_assert_not_reached ();
 }
 
+/**
+ * mono_context_set:
+ */
 void
-mono_context_init_checked (MonoDomain *domain, MonoError *error)
+mono_context_set (MonoAppContext * new_context)
 {
-	HANDLE_FUNCTION_ENTER ();
-
-	MonoClass *klass;
-	MonoAppContextHandle context;
+}
 
-	error_init (error);
-	if (mono_runtime_get_no_exec ())
-		goto exit;
+void
+mono_context_set_handle (MonoAppContextHandle new_context)
+{
+}
 
-	klass = mono_class_load_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Contexts", "Context");
-	context = MONO_HANDLE_CAST (MonoAppContext, mono_object_new_pinned_handle (domain, klass, error));
-	goto_if_nok (error, exit);
+/**
+ * mono_context_get:
+ *
+ * Returns: the current Mono Application Context.
+ */
+MonoAppContext *
+mono_context_get (void)
+{
+	return NULL;
+}
 
-	MONO_HANDLE_SETVAL (context, domain_id, gint32, domain->domain_id);
-	MONO_HANDLE_SETVAL (context, context_id, gint32, 0);
-	mono_threads_register_app_context (context, error);
-	mono_error_assert_ok (error);
-	domain->default_context = MONO_HANDLE_RAW (context);
-exit:
-	HANDLE_FUNCTION_RETURN ();
+/**
+ * mono_context_get_handle:
+ *
+ * Returns: the current Mono Application Context.
+ */
+MonoAppContextHandle
+mono_context_get_handle (void)
+{
+	return MONO_HANDLE_NEW (MonoAppContext, NULL);
 }
 
 /**
@@ -662,15 +662,6 @@ mono_domain_owns_vtable_slot (MonoDomain *domain, gpointer vtable_slot)
 	return res;
 }
 
-gboolean
-mono_domain_set_fast (MonoDomain *domain, gboolean force)
-{
-	MONO_REQ_GC_UNSAFE_MODE;
-
-	mono_domain_set_internal_with_options (domain, TRUE);
-	return TRUE;
-}
-
 static gboolean
 add_assembly_to_array (MonoDomain *domain, MonoArrayHandle dest, int dest_idx, MonoAssembly* assm, MonoError *error)
 {
diff --git a/src/mono/mono/metadata/assembly-load-context.c b/src/mono/mono/metadata/assembly-load-context.c
index d925fa31864100..e2bce184f86f8d 100644
--- a/src/mono/mono/metadata/assembly-load-context.c
+++ b/src/mono/mono/metadata/assembly-load-context.c
@@ -21,7 +21,7 @@ mono_alc_init (MonoAssemblyLoadContext *alc, MonoDomain *domain, gboolean collec
 	alc->domain = domain;
 	alc->loaded_images = li;
 	alc->loaded_assemblies = NULL;
-	alc->memory_manager = mono_mem_manager_create_singleton (alc, domain, collectible);
+	alc->memory_manager = mono_mem_manager_create_singleton (alc, collectible);
 	alc->generic_memory_managers = g_ptr_array_new ();
 	mono_coop_mutex_init (&alc->memory_managers_lock);
 	alc->unloading = FALSE;
diff --git a/src/mono/mono/metadata/class-init.c b/src/mono/mono/metadata/class-init.c
index ae5cb541dac76a..0a59ad59338fbb 100644
--- a/src/mono/mono/metadata/class-init.c
+++ b/src/mono/mono/metadata/class-init.c
@@ -3961,7 +3961,6 @@ mono_class_setup_nested_types (MonoClass *klass)
 /**
  * mono_class_setup_runtime_info:
  * \param klass the class to setup
- * \param domain the domain of the \p vtable
  * \param vtable
  *
  * Store \p vtable in \c klass->runtime_info.
@@ -3972,36 +3971,17 @@ mono_class_setup_nested_types (MonoClass *klass)
  * LOCKING: domain lock and loaderlock must be held.
  */
 void
-mono_class_setup_runtime_info (MonoClass *klass, MonoDomain *domain, MonoVTable *vtable)
+mono_class_setup_runtime_info (MonoClass *klass, MonoVTable *vtable)
 {
 	MonoClassRuntimeInfo *old_info = m_class_get_runtime_info (klass);
-	if (old_info && old_info->max_domain >= domain->domain_id) {
-		/* someone already created a large enough runtime info */
-		old_info->domain_vtables [domain->domain_id] = vtable;
-	} else {
-		int new_size = domain->domain_id;
-		if (old_info)
-			new_size = MAX (new_size, old_info->max_domain);
-		new_size++;
-		/* make the new size a power of two */
-		int i = 2;
-		while (new_size > i)
-			i <<= 1;
-		new_size = i;
-		/* this is a bounded memory retention issue: may want to 
-		 * handle it differently when we'll have a rcu-like system.
-		 */
-		MonoClassRuntimeInfo *runtime_info = (MonoClassRuntimeInfo *)mono_image_alloc0 (m_class_get_image (klass), MONO_SIZEOF_CLASS_RUNTIME_INFO + new_size * sizeof (gpointer));
-		runtime_info->max_domain = new_size - 1;
-		/* copy the stuff from the older info */
-		if (old_info) {
-			memcpy (runtime_info->domain_vtables, old_info->domain_vtables, (old_info->max_domain + 1) * sizeof (gpointer));
-		}
-		runtime_info->domain_vtables [domain->domain_id] = vtable;
-		/* keep this last*/
-		mono_memory_barrier ();
-		klass->runtime_info = runtime_info;
-	}
+	if (old_info)
+		return;
+
+	MonoClassRuntimeInfo *runtime_info = (MonoClassRuntimeInfo *)mono_image_alloc0 (m_class_get_image (klass), sizeof (MonoClassRuntimeInfo));
+	runtime_info->domain_vtable = vtable;
+	/* keep this last*/
+	mono_memory_barrier ();
+	klass->runtime_info = runtime_info;
 }
 
 /**
diff --git a/src/mono/mono/metadata/class-init.h b/src/mono/mono/metadata/class-init.h
index 3570f7f9aab38d..8a03d50ebb19e1 100644
--- a/src/mono/mono/metadata/class-init.h
+++ b/src/mono/mono/metadata/class-init.h
@@ -83,7 +83,7 @@ void
 mono_class_setup_nested_types (MonoClass *klass);
 
 void
-mono_class_setup_runtime_info (MonoClass *klass, MonoDomain *domain, MonoVTable *vtable);
+mono_class_setup_runtime_info (MonoClass *klass, MonoVTable *vtable);
 
 MonoClass *
 mono_class_create_array_fill_type (void);
diff --git a/src/mono/mono/metadata/class-internals.h b/src/mono/mono/metadata/class-internals.h
index b1d1dbe4adee9d..93bc5fe5a618bc 100644
--- a/src/mono/mono/metadata/class-internals.h
+++ b/src/mono/mono/metadata/class-internals.h
@@ -227,13 +227,9 @@ typedef enum {
  * like the vtables for a domain, the GC descriptor, etc.
  */
 typedef struct {
-	guint16 max_domain;
-	/* domain_vtables is indexed by the domain id and the size is max_domain + 1 */
-	MonoVTable *domain_vtables [MONO_ZERO_LEN_ARRAY];
+	MonoVTable *domain_vtable;
 } MonoClassRuntimeInfo;
 
-#define MONO_SIZEOF_CLASS_RUNTIME_INFO (sizeof (MonoClassRuntimeInfo) - MONO_ZERO_LEN_ARRAY * SIZEOF_VOID_P)
-
 typedef struct {
 	MonoPropertyBagItem head;
 
diff --git a/src/mono/mono/metadata/cominterop.c b/src/mono/mono/metadata/cominterop.c
index 59a47e89596af1..0f5a43a52a9789 100644
--- a/src/mono/mono/metadata/cominterop.c
+++ b/src/mono/mono/metadata/cominterop.c
@@ -1994,12 +1994,7 @@ cominterop_set_ccw_object_domain (MonoObject *object, MonoDomain **prev_domain)
 	else
 		obj_domain = mono_object_domain (object);
 
-	if (obj_domain != current) {
-		*prev_domain = current;
-		mono_domain_set_internal_with_options (obj_domain, FALSE);
-	}
-	else
-		*prev_domain = NULL;
+	*prev_domain = NULL;
 
 	return object;
 }
@@ -2009,8 +2004,6 @@ cominterop_restore_domain (MonoDomain *domain)
 {
 	if (!domain)
 		return;
-
-	mono_domain_set_internal_with_options (domain, FALSE);
 }
 
 static void
diff --git a/src/mono/mono/metadata/domain-internals.h b/src/mono/mono/metadata/domain-internals.h
index 59d18534296250..68eab549651161 100644
--- a/src/mono/mono/metadata/domain-internals.h
+++ b/src/mono/mono/metadata/domain-internals.h
@@ -23,14 +23,6 @@
 
 G_BEGIN_DECLS
 
-/*
- * If this is set, the memory belonging to appdomains is not freed when a domain is
- * unloaded, and assemblies loaded by the appdomain are not unloaded either. This
- * allows us to use typed gc in non-default appdomains too, leading to increased
- * performance.
- */ 
-extern gboolean mono_dont_free_domains;
-
 typedef struct _MonoJitInfoTable MonoJitInfoTable;
 typedef struct _MonoJitInfoTableChunk MonoJitInfoTableChunk;
 
@@ -307,8 +299,6 @@ struct _MonoDomain {
 	MonoGHashTable     *ldstr_table;
 #define MONO_DOMAIN_LAST_GC_TRACKED ldstr_table
 	guint32            state;
-	/* Needed by Thread:GetDomainID() */
-	gint32             domain_id;
 	/*
 	 * For framework Mono, this is every assembly loaded in this
 	 * domain. For netcore, this is every assembly loaded in every ALC in
@@ -429,17 +419,9 @@ typedef void (*MonoCreateDomainFunc) (MonoDomain *domain);
 void
 mono_install_create_domain_hook (MonoCreateDomainFunc func);
 
-typedef void (*MonoFreeDomainFunc) (MonoDomain *domain);
-
-void
-mono_install_free_domain_hook (MonoFreeDomainFunc func);
-
 void
 mono_runtime_quit_internal (void);
 
-void 
-mono_cleanup (void);
-
 void
 mono_close_exe_image (void);
 
@@ -493,12 +475,6 @@ mono_domain_alloc0_lock_free (MonoDomain *domain, guint size);
 
 #define mono_domain_alloc0_lock_free(domain, size) (g_cast (mono_domain_alloc0_lock_free ((domain), (size))))
 
-void
-mono_domain_unset (void);
-
-void
-mono_domain_set_internal_with_options (MonoDomain *domain, gboolean migrate_exception);
-
 MonoTryBlockHoleTableJitInfo*
 mono_jit_info_get_try_block_hole_table_info (MonoJitInfo *ji);
 
@@ -557,14 +533,9 @@ typedef void (*MonoJitInfoFunc) (MonoJitInfo *ji, gpointer user_data);
 void
 mono_jit_info_table_foreach_internal (MonoDomain *domain, MonoJitInfoFunc func, gpointer user_data);
 
-void mono_enable_debug_domain_unload (gboolean enable);
-
 void
 mono_runtime_init_checked (MonoDomain *domain, MonoThreadStartCB start_cb, MonoThreadAttachCB attach_cb, MonoError *error);
 
-void
-mono_context_init_checked (MonoDomain *domain, MonoError *error);
-
 gboolean
 mono_assembly_has_reference_assembly_attribute (MonoAssembly *assembly, MonoError *error);
 
@@ -577,9 +548,6 @@ mono_runtime_register_appctx_properties (int nprops, const char **keys,  const c
 void
 mono_runtime_install_appctx_properties (void);
 
-gboolean 
-mono_domain_set_fast (MonoDomain *domain, gboolean force);
-
 MonoAssemblyLoadContext *
 mono_domain_default_alc (MonoDomain *domain);
 
diff --git a/src/mono/mono/metadata/domain.c b/src/mono/mono/metadata/domain.c
index 233e60d987e9cf..acd105edbe5c5a 100644
--- a/src/mono/mono/metadata/domain.c
+++ b/src/mono/mono/metadata/domain.c
@@ -54,36 +54,9 @@
 #include "external-only.h"
 #include "mono/utils/mono-tls-inline.h"
 
-#define GET_APPDOMAIN    mono_tls_get_domain
-#define SET_APPDOMAIN(x) do { \
-	MonoThreadInfo *info; \
-	mono_tls_set_domain (x); \
-	info = mono_thread_info_current (); \
-	if (info) \
-		mono_thread_info_tls_set (info, TLS_KEY_DOMAIN, (x));	\
-} while (FALSE)
-
-#define GET_APPCONTEXT() NULL
-#define SET_APPCONTEXT(x)
-
-static guint16 appdomain_list_size = 0;
-static guint16 appdomain_next = 0;
-static MonoDomain **appdomains_list = NULL;
 static MonoImage *exe_image;
-
-gboolean mono_dont_free_domains;
-
-#define mono_appdomains_lock() mono_coop_mutex_lock (&appdomains_mutex)
-#define mono_appdomains_unlock() mono_coop_mutex_unlock (&appdomains_mutex)
-static MonoCoopMutex appdomains_mutex;
-
 static MonoDomain *mono_root_domain = NULL;
 
-/* some statistics */
-static int max_domain_code_size = 0;
-static int max_domain_code_alloc = 0;
-static int total_domain_code_alloc = 0;
-
 /* AppConfigInfo: Information about runtime versions supported by an 
  * aplication.
  */
@@ -114,7 +87,6 @@ static const MonoRuntimeInfo supported_runtimes[] = {
 
 /* Callbacks installed by the JIT */
 static MonoCreateDomainFunc create_domain_hook;
-static MonoFreeDomainFunc free_domain_hook;
 
 /* AOT cache configuration */
 static MonoAotCacheConfig aot_cache_config;
@@ -217,12 +189,6 @@ mono_install_create_domain_hook (MonoCreateDomainFunc func)
 	create_domain_hook = func;
 }
 
-void
-mono_install_free_domain_hook (MonoFreeDomainFunc func)
-{
-	free_domain_hook = func;
-}
-
 gboolean
 mono_string_equal_internal (MonoString *s1, MonoString *s2)
 {
@@ -303,75 +269,6 @@ mono_ptrarray_hash (gpointer *s)
 	return hash;	
 }
 
-//g_malloc on sgen and mono_gc_alloc_fixed on boehm
-static void*
-gc_alloc_fixed_non_heap_list (size_t size)
-{
-	if (mono_gc_is_moving ())
-		return g_malloc0 (size);
-	else
-		return mono_gc_alloc_fixed (size, MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_DOMAIN, NULL, "Domain List");
-}
-
-static void
-gc_free_fixed_non_heap_list (void *ptr)
-{
-	if (mono_gc_is_moving ())
-		g_free (ptr);
-	else
-		mono_gc_free_fixed (ptr);
-}
-/*
- * Allocate an id for domain and set domain->domain_id.
- * LOCKING: must be called while holding appdomains_mutex.
- * We try to assign low numbers to the domain, so it can be used
- * as an index in data tables to lookup domain-specific info
- * with minimal memory overhead. We also try not to reuse the
- * same id too quickly (to help debugging).
- */
-static int
-domain_id_alloc (MonoDomain *domain)
-{
-	int id = -1, i;
-	if (!appdomains_list) {
-		appdomain_list_size = 2;
-		appdomains_list = (MonoDomain **)gc_alloc_fixed_non_heap_list (appdomain_list_size * sizeof (void*));
-
-	}
-	for (i = appdomain_next; i < appdomain_list_size; ++i) {
-		if (!appdomains_list [i]) {
-			id = i;
-			break;
-		}
-	}
-	if (id == -1) {
-		for (i = 0; i < appdomain_next; ++i) {
-			if (!appdomains_list [i]) {
-				id = i;
-				break;
-			}
-		}
-	}
-	if (id == -1) {
-		MonoDomain **new_list;
-		int new_size = appdomain_list_size * 2;
-		if (new_size >= (1 << 16))
-			g_assert_not_reached ();
-		id = appdomain_list_size;
-		new_list = (MonoDomain **)gc_alloc_fixed_non_heap_list (new_size * sizeof (void*));
-		memcpy (new_list, appdomains_list, appdomain_list_size * sizeof (void*));
-		gc_free_fixed_non_heap_list (appdomains_list);
-		appdomains_list = new_list;
-		appdomain_list_size = new_size;
-	}
-	domain->domain_id = id;
-	appdomains_list [id] = domain;
-	appdomain_next++;
-	if (appdomain_next > appdomain_list_size)
-		appdomain_next = 0;
-	return id;
-}
-
 static gsize domain_gc_bitmap [sizeof(MonoDomain)/4/32 + 1];
 static MonoGCDescriptor domain_gc_desc = MONO_GC_DESCRIPTOR_NULL;
 
@@ -400,9 +297,7 @@ MonoDomain *
 mono_domain_create (void)
 {
 	MonoDomain *domain;
-  
-	mono_appdomains_lock ();
-  
+
 	if (!domain_gc_desc) {
 		unsigned int i, bit = 0;
 		for (i = G_STRUCT_OFFSET (MonoDomain, MONO_DOMAIN_FIRST_OBJECT); i < G_STRUCT_OFFSET (MonoDomain, MONO_DOMAIN_FIRST_GC_TRACKED); i += sizeof (gpointer)) {
@@ -411,7 +306,6 @@ mono_domain_create (void)
 		}
 		domain_gc_desc = mono_gc_make_descr_from_bitmap ((gsize*)domain_gc_bitmap, bit + 1);
 	}
-	mono_appdomains_unlock ();
 
 	if (!mono_gc_is_moving ())
 		domain = (MonoDomain *)mono_gc_alloc_fixed (sizeof (MonoDomain), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_DOMAIN, NULL, "Domain Structure");
@@ -443,10 +337,6 @@ mono_domain_create (void)
 
 	mono_coop_mutex_init (&domain->alcs_lock);
 
-	mono_appdomains_lock ();
-	domain_id_alloc (domain);
-	mono_appdomains_unlock ();
-
 #ifndef DISABLE_PERFCOUNTERS
 	mono_atomic_inc_i32 (&mono_perfcounters->loader_appdomains);
 	mono_atomic_inc_i32 (&mono_perfcounters->loader_total_appdomains);
@@ -480,12 +370,11 @@ mono_domain_create (void)
 static MonoDomain *
 mono_init_internal (const char *filename, const char *exe_filename, const char *runtime_version)
 {
-	static MonoDomain *domain = NULL;
 	MonoAssembly *ass = NULL;
 	MonoImageOpenStatus status = MONO_IMAGE_OK;
 	GSList *runtimes = NULL;
 
-	if (domain)
+	if (mono_root_domain)
 		g_assert_not_reached ();
 
 #if defined(HOST_WIN32) && HAVE_API_SUPPORT_WIN32_SET_ERROR_MODE
@@ -508,17 +397,11 @@ mono_init_internal (const char *filename, const char *exe_filename, const char *
 #endif
 	mono_counters_init ();
 
-	mono_counters_register ("Max native code in a domain", MONO_COUNTER_INT|MONO_COUNTER_JIT, &max_domain_code_size);
-	mono_counters_register ("Max code space allocated in a domain", MONO_COUNTER_INT|MONO_COUNTER_JIT, &max_domain_code_alloc);
-	mono_counters_register ("Total code space allocated", MONO_COUNTER_INT|MONO_COUNTER_JIT, &total_domain_code_alloc);
-
 	mono_counters_register ("Max HashTable Chain Length", MONO_COUNTER_INT|MONO_COUNTER_METADATA, &mono_g_hash_table_max_chain_length);
 
 	mono_gc_base_init ();
 	mono_thread_info_attach ();
 
-	mono_coop_mutex_init_recursive (&appdomains_mutex);
-
 	mono_metadata_init ();
 	mono_images_init ();
 	mono_assemblies_init ();
@@ -528,10 +411,8 @@ mono_init_internal (const char *filename, const char *exe_filename, const char *
 	mono_runtime_init_tls ();
 	mono_icall_init ();
 
-	domain = mono_domain_create ();
-	mono_root_domain = domain;
-
-	SET_APPDOMAIN (domain);
+	mono_root_domain = mono_domain_create ();
+	MonoDomain *domain = mono_root_domain;
 
 #if defined(ENABLE_EXPERIMENT_null)
 	if (mono_experiment_enabled (MONO_EXPERIMENT_null))
@@ -806,32 +687,6 @@ mono_init_version (const char *domain_name, const char *version)
 	return mono_init_internal (domain_name, NULL, version);
 }
 
-/**
- * mono_cleanup:
- *
- * Cleans up all metadata modules. 
- */
-void
-mono_cleanup (void)
-{
-	mono_close_exe_image ();
-
-	mono_thread_info_cleanup ();
-
-	mono_defaults.corlib = NULL;
-
-	mono_loader_cleanup ();
-	mono_classes_cleanup ();
-	mono_assemblies_cleanup ();
-	mono_debug_cleanup ();
-	mono_images_cleanup ();
-	mono_metadata_cleanup ();
-
-	mono_coop_mutex_destroy (&appdomains_mutex);
-
-	mono_w32file_cleanup ();
-}
-
 void
 mono_close_exe_image (void)
 {
@@ -872,36 +727,7 @@ mono_get_root_domain (void)
 MonoDomain *
 mono_domain_get ()
 {
-	return GET_APPDOMAIN ();
-}
-
-void
-mono_domain_unset (void)
-{
-	SET_APPDOMAIN (NULL);
-}
-
-void
-mono_domain_set_internal_with_options (MonoDomain *domain, gboolean migrate_exception)
-{
-	MONO_REQ_GC_UNSAFE_MODE;
-	MonoInternalThread *thread;
-
-	if (mono_domain_get () == domain)
-		return;
-
-	SET_APPDOMAIN (domain);
-	SET_APPCONTEXT (domain->default_context);
-
-	if (migrate_exception) {
-		thread = mono_thread_internal_current ();
-		if (!thread->abort_exc)
-			return;
-
-		g_assert (thread->abort_exc->object.vtable->domain != domain);
-		MONO_OBJECT_SETREF_INTERNAL (thread, abort_exc, mono_get_exception_thread_abort ());
-		g_assert (thread->abort_exc->object.vtable->domain == domain);
-	}
+	return mono_root_domain;
 }
 
 /**
@@ -918,26 +744,7 @@ void
 mono_domain_foreach (MonoDomainFunc func, gpointer user_data)
 {
 	MONO_ENTER_GC_UNSAFE;
-	int i, size;
-	MonoDomain **copy;
-
-	/*
-	 * Create a copy of the data to avoid calling the user callback
-	 * inside the lock because that could lead to deadlocks.
-	 * We can do this because this function is not perf. critical.
-	 */
-	mono_appdomains_lock ();
-	size = appdomain_list_size;
-	copy = (MonoDomain **)gc_alloc_fixed_non_heap_list (appdomain_list_size * sizeof (void*));
-	memcpy (copy, appdomains_list, appdomain_list_size * sizeof (void*));
-	mono_appdomains_unlock ();
-
-	for (i = 0; i < size; ++i) {
-		if (copy [i])
-			func (copy [i], user_data);
-	}
-
-	gc_free_fixed_non_heap_list (copy);
+	func (mono_domain_get (), user_data);
 	MONO_EXIT_GC_UNSAFE;
 }
 
@@ -945,7 +752,6 @@ void
 mono_domain_ensure_entry_assembly (MonoDomain *domain, MonoAssembly *assembly)
 {
 	if (!mono_runtime_get_no_exec () && !domain->entry_assembly && assembly) {
-
 		domain->entry_assembly = assembly;
 	}
 }
@@ -970,26 +776,17 @@ mono_domain_assembly_open (MonoDomain *domain, const char *name)
 MonoAssembly *
 mono_domain_assembly_open_internal (MonoDomain *domain, MonoAssemblyLoadContext *alc, const char *name)
 {
-	MonoDomain *current;
 	MonoAssembly *ass;
 
 	MONO_REQ_GC_UNSAFE_MODE;
 
 	MonoAssemblyOpenRequest req;
 	mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, alc);
-	if (domain != mono_domain_get ()) {
-		current = mono_domain_get ();
-
-		mono_domain_set_fast (domain, FALSE);
-		ass = mono_assembly_request_open (name, &req, NULL);
-		mono_domain_set_fast (current, FALSE);
-	} else {
-		ass = mono_assembly_request_open (name, &req, NULL);
-	}
+	ass = mono_assembly_request_open (name, &req, NULL);
 
 	// On netcore, this is necessary because we check the AppContext.BaseDirectory property as part of the assembly lookup algorithm
 	// AppContext.BaseDirectory can sometimes fall back to checking the location of the entry_assembly, which should be non-null
-	mono_domain_ensure_entry_assembly (domain, ass);
+	mono_domain_ensure_entry_assembly (mono_domain_get (), ass);
 
 	return ass;
 }
@@ -1019,17 +816,7 @@ mono_domain_free (MonoDomain *domain, gboolean force)
 MonoDomain * 
 mono_domain_get_by_id (gint32 domainid) 
 {
-	MonoDomain * domain;
-
-	MONO_ENTER_GC_UNSAFE;
-	mono_appdomains_lock ();
-	if (domainid < appdomain_list_size)
-		domain = appdomains_list [domainid];
-	else
-		domain = NULL;
-	mono_appdomains_unlock ();
-	MONO_EXIT_GC_UNSAFE;
-	return domain;
+	return mono_domain_get ();
 }
 
 /**
@@ -1044,7 +831,7 @@ mono_domain_get_by_id (gint32 domainid)
 gint32
 mono_domain_get_id (MonoDomain *domain)
 {
-	return domain->domain_id;
+	return 0;
 }
 
 /**
@@ -1093,43 +880,6 @@ gpointer
 	return lock_free_mempool_alloc0 (domain->lock_free_mp, size);
 }
 
-/**
- * mono_context_set:
- */
-void 
-mono_context_set (MonoAppContext * new_context)
-{
-	SET_APPCONTEXT (new_context);
-}
-
-void
-mono_context_set_handle (MonoAppContextHandle new_context)
-{
-	SET_APPCONTEXT (MONO_HANDLE_RAW (new_context));
-}
-
-/**
- * mono_context_get:
- *
- * Returns: the current Mono Application Context.
- */
-MonoAppContext * 
-mono_context_get (void)
-{
-	return GET_APPCONTEXT ();
-}
-
-/**
- * mono_context_get_handle:
- *
- * Returns: the current Mono Application Context.
- */
-MonoAppContextHandle
-mono_context_get_handle (void)
-{
-	return MONO_HANDLE_NEW (MonoAppContext, GET_APPCONTEXT ());
-}
-
 /**
  * mono_context_get_id:
  * \param context the context to operate on.
@@ -1153,7 +903,7 @@ mono_context_get_id (MonoAppContext *context)
 gint32
 mono_context_get_domain_id (MonoAppContext *context)
 {
-	return context->domain_id;
+	return 0;
 }
 
 /**
diff --git a/src/mono/mono/metadata/exception.c b/src/mono/mono/metadata/exception.c
index 63cc247ec7c1fe..3fa602630a69e0 100644
--- a/src/mono/mono/metadata/exception.c
+++ b/src/mono/mono/metadata/exception.c
@@ -95,23 +95,14 @@ mono_exception_new_by_name_domain (MonoDomain *domain, MonoImage *image,
 {
 	HANDLE_FUNCTION_ENTER ();
 
-	MonoDomain * const caller_domain = mono_domain_get ();
-
 	MonoClass * const klass = mono_class_load_from_name (image, name_space, name);
 
 	MonoObjectHandle o = mono_object_new_handle (domain, klass, error);
 	goto_if_nok (error, return_null);
 
-	if (domain != caller_domain)
-		mono_domain_set_internal_with_options (domain, TRUE);
-
 	mono_runtime_object_init_handle (o, error);
 	mono_error_assert_ok (error);
 
-	// Restore domain in success and error path.
-	if (domain != caller_domain)
-		mono_domain_set_internal_with_options (caller_domain, TRUE);
-
 	goto_if_ok (error, exit);
 return_null:
 	MONO_HANDLE_ASSIGN (o, NULL_HANDLE);
diff --git a/src/mono/mono/metadata/external-only.c b/src/mono/mono/metadata/external-only.c
index a86dd113224788..b60d37419c277b 100644
--- a/src/mono/mono/metadata/external-only.c
+++ b/src/mono/mono/metadata/external-only.c
@@ -327,7 +327,7 @@ mono_class_is_subclass_of (MonoClass *klass, MonoClass *klassc, gboolean check_i
 void
 mono_domain_set_internal (MonoDomain *domain)
 {
-	MONO_EXTERNAL_ONLY_GC_UNSAFE_VOID (mono_domain_set_internal_with_options (domain, TRUE));
+	g_assert_not_reached ();
 }
 
 /**
@@ -343,8 +343,7 @@ mono_domain_set_internal (MonoDomain *domain)
 gboolean
 mono_domain_set (MonoDomain *domain, gboolean force)
 {
-	MONO_EXTERNAL_ONLY_GC_UNSAFE_VOID (mono_domain_set_internal_with_options (domain, TRUE));
-	return TRUE;
+	g_assert_not_reached ();
 }
 
 /**
diff --git a/src/mono/mono/metadata/gc-internals.h b/src/mono/mono/metadata/gc-internals.h
index 97674106ca11c7..0afd40050f8907 100644
--- a/src/mono/mono/metadata/gc-internals.h
+++ b/src/mono/mono/metadata/gc-internals.h
@@ -184,7 +184,6 @@ MONO_API int   mono_gc_register_root (char *start, size_t size, MonoGCDescriptor
 void  mono_gc_deregister_root (char* addr);
 void  mono_gc_finalize_domain (MonoDomain *domain);
 void  mono_gc_run_finalize (void *obj, void *data);
-void  mono_gc_clear_domain (MonoDomain * domain);
 /* Signal early termination of finalizer processing inside the gc */
 void  mono_gc_suspend_finalizers (void);
 
diff --git a/src/mono/mono/metadata/gc.c b/src/mono/mono/metadata/gc.c
index e1f303c2933d76..df4fb584c8c08c 100644
--- a/src/mono/mono/metadata/gc.c
+++ b/src/mono/mono/metadata/gc.c
@@ -177,7 +177,6 @@ mono_gc_run_finalize (void *obj, void *data)
 	MonoObject *o2;
 #endif
 	MonoMethod* finalizer = NULL;
-	MonoDomain *caller_domain = mono_domain_get ();
 	MonoDomain *domain;
 
 	// This function is called from the innards of the GC, so our best alternative for now is to do polling here
@@ -256,9 +255,6 @@ mono_gc_run_finalize (void *obj, void *data)
 	/* speedup later... and use a timeout */
 	/* g_print ("Finalize run on %p %s.%s\n", o, mono_object_class (o)->name_space, mono_object_class (o)->name); */
 
-	/* Use _internal here, since this thread can enter a doomed appdomain */
-	mono_domain_set_internal_with_options (mono_object_domain (o), TRUE);
-
 	/* delegates that have a native function pointer allocated are
 	 * registered for finalization, but they don't have a Finalize
 	 * method, because in most cases it's not needed and it's just a waste.
@@ -267,7 +263,6 @@ mono_gc_run_finalize (void *obj, void *data)
 		MonoDelegate* del = (MonoDelegate*)o;
 		if (del->delegate_trampoline)
 			mono_delegate_free_ftnptr ((MonoDelegate*)o);
-		mono_domain_set_internal_with_options (caller_domain, TRUE);
 		return;
 	}
 
@@ -280,7 +275,6 @@ mono_gc_run_finalize (void *obj, void *data)
 	 * of finalizer on object with CCW.
 	 */
 	if (mono_marshal_free_ccw (o) && !finalizer) {
-		mono_domain_set_internal_with_options (caller_domain, TRUE);
 		return;
 	}
 
@@ -338,8 +332,6 @@ mono_gc_run_finalize (void *obj, void *data)
 		exc = (MonoObject*)mono_error_convert_to_exception (error);
 	if (exc)
 		mono_thread_internal_unhandled_exception (exc);
-
-	mono_domain_set_internal_with_options (caller_domain, TRUE);
 }
 
 /*
diff --git a/src/mono/mono/metadata/jit-icall-reg.h b/src/mono/mono/metadata/jit-icall-reg.h
index 6a66e5ecc4379a..d7439282ac3164 100644
--- a/src/mono/mono/metadata/jit-icall-reg.h
+++ b/src/mono/mono/metadata/jit-icall-reg.h
@@ -247,7 +247,6 @@ MONO_JIT_ICALL (mono_marshal_safearray_free_indices) \
 MONO_JIT_ICALL (mono_marshal_safearray_get_value) \
 MONO_JIT_ICALL (mono_marshal_safearray_next) \
 MONO_JIT_ICALL (mono_marshal_safearray_set_value) \
-MONO_JIT_ICALL (mono_marshal_set_domain_by_id) \
 MONO_JIT_ICALL (mono_marshal_set_last_error) \
 MONO_JIT_ICALL (mono_marshal_set_last_error_windows) \
 MONO_JIT_ICALL (mono_marshal_string_to_utf16) \
diff --git a/src/mono/mono/metadata/loader-internals.h b/src/mono/mono/metadata/loader-internals.h
index c58f4ed03cfcea..e6f2d4e39e0607 100644
--- a/src/mono/mono/metadata/loader-internals.h
+++ b/src/mono/mono/metadata/loader-internals.h
@@ -191,7 +191,7 @@ MONO_API void
 mono_loader_save_bundled_library (int fd, uint64_t offset, uint64_t size, const char *destfname);
 
 MonoSingletonMemoryManager *
-mono_mem_manager_create_singleton (MonoAssemblyLoadContext *alc, MonoDomain *domain, gboolean collectible);
+mono_mem_manager_create_singleton (MonoAssemblyLoadContext *alc, gboolean collectible);
 
 void
 mono_mem_manager_free_singleton (MonoSingletonMemoryManager *memory_manager, gboolean debug_unload);
diff --git a/src/mono/mono/metadata/memory-manager.c b/src/mono/mono/metadata/memory-manager.c
index f61cb422a7bba3..2dc8dbb34a6b1f 100644
--- a/src/mono/mono/metadata/memory-manager.c
+++ b/src/mono/mono/metadata/memory-manager.c
@@ -4,9 +4,9 @@
 #include <mono/metadata/mono-hash-internals.h>
 
 static void
-memory_manager_init (MonoMemoryManager *memory_manager, MonoDomain *domain, gboolean collectible)
+memory_manager_init (MonoMemoryManager *memory_manager, gboolean collectible)
 {
-	memory_manager->domain = domain;
+	MonoDomain *domain = mono_domain_get ();
 	memory_manager->freeing = FALSE;
 
 	mono_coop_mutex_init_recursive (&memory_manager->lock);
@@ -23,10 +23,10 @@ memory_manager_init (MonoMemoryManager *memory_manager, MonoDomain *domain, gboo
 }
 
 MonoSingletonMemoryManager *
-mono_mem_manager_create_singleton (MonoAssemblyLoadContext *alc, MonoDomain *domain, gboolean collectible)
+mono_mem_manager_create_singleton (MonoAssemblyLoadContext *alc, gboolean collectible)
 {
 	MonoSingletonMemoryManager *mem_manager = g_new0 (MonoSingletonMemoryManager, 1);
-	memory_manager_init ((MonoMemoryManager *)mem_manager, domain, collectible);
+	memory_manager_init ((MonoMemoryManager *)mem_manager, collectible);
 
 	mem_manager->memory_manager.is_generic = FALSE;
 	mem_manager->alc = alc;
@@ -117,14 +117,14 @@ void
 mono_mem_manager_lock (MonoMemoryManager *memory_manager)
 {
 	//mono_coop_mutex_lock (&memory_manager->lock);
-	mono_domain_lock (memory_manager->domain);
+	mono_domain_lock (mono_domain_get ());
 }
 
 void
 mono_mem_manager_unlock (MonoMemoryManager *memory_manager)
 {
 	//mono_coop_mutex_unlock (&memory_manager->lock);
-	mono_domain_unlock (memory_manager->domain);
+	mono_domain_unlock (mono_domain_get ());
 }
 
 void *
diff --git a/src/mono/mono/metadata/metadata-internals.h b/src/mono/mono/metadata/metadata-internals.h
index 00da328506778b..32022309202d04 100644
--- a/src/mono/mono/metadata/metadata-internals.h
+++ b/src/mono/mono/metadata/metadata-internals.h
@@ -718,7 +718,6 @@ typedef struct _MonoAssemblyBindingInfo {
 	guint has_old_version_top : 1;
 	guint has_new_version : 1;
 	guint is_valid : 1;
-	gint32 domain_id; /*Needed to unload per-domain binding*/
 } MonoAssemblyBindingInfo;
 
 struct _MonoMethodHeader {
diff --git a/src/mono/mono/metadata/object.c b/src/mono/mono/metadata/object.c
index d6283689a1ec23..287ad1777689c7 100644
--- a/src/mono/mono/metadata/object.c
+++ b/src/mono/mono/metadata/object.c
@@ -475,7 +475,6 @@ mono_runtime_class_init_full (MonoVTable *vtable, MonoError *error)
 	}
 
 	gboolean do_initialization = FALSE;
-	MonoDomain *last_domain = NULL;
 	TypeInitializationLock *lock = NULL;
 	gboolean pending_tae = FALSE;
 
@@ -497,11 +496,6 @@ mono_runtime_class_init_full (MonoVTable *vtable, MonoError *error)
 	lock = (TypeInitializationLock *)g_hash_table_lookup (type_initialization_hash, vtable);
 	if (lock == NULL) {
 		/* This thread will get to do the initialization */
-		if (mono_domain_get () != domain) {
-			/* Transfer into the target domain */
-			last_domain = mono_domain_get ();
-			mono_domain_set_fast (domain, FALSE);
-		}
 		lock = (TypeInitializationLock *)g_malloc0 (sizeof (TypeInitializationLock));
 		mono_coop_mutex_init_recursive (&lock->mutex);
 		mono_coop_cond_init (&lock->cond);
@@ -594,9 +588,6 @@ mono_runtime_class_init_full (MonoVTable *vtable, MonoError *error)
 			mono_mem_manager_unlock (memory_manager);
 		}
 
-		if (last_domain)
-			mono_domain_set_fast (last_domain, TRUE);
-
 		/* Signal to the other threads that we are done */
 		mono_type_init_lock (lock);
 		lock->done = TRUE;
@@ -1913,8 +1904,8 @@ mono_class_vtable_checked (MonoDomain *domain, MonoClass *klass, MonoError *erro
 
 	/* this check can be inlined in jitted code, too */
 	runtime_info = m_class_get_runtime_info (klass);
-	if (runtime_info && runtime_info->max_domain >= domain->domain_id && runtime_info->domain_vtables [domain->domain_id])
-		return runtime_info->domain_vtables [domain->domain_id];
+	if (runtime_info)
+		return runtime_info->domain_vtable;
 	return mono_class_create_runtime_vtable (domain, klass, error);
 }
 
@@ -1930,13 +1921,10 @@ mono_class_try_get_vtable (MonoDomain *domain, MonoClass *klass)
 {
 	MONO_REQ_GC_NEUTRAL_MODE;
 
-	MonoClassRuntimeInfo *runtime_info;
-
 	g_assert (klass);
 
-	runtime_info = m_class_get_runtime_info (klass);
-	if (runtime_info && runtime_info->max_domain >= domain->domain_id && runtime_info->domain_vtables [domain->domain_id])
-		return runtime_info->domain_vtables [domain->domain_id];
+	if (m_class_get_runtime_info (klass))
+		return m_class_get_runtime_info (klass)->domain_vtable;
 	return NULL;
 }
 
@@ -1988,10 +1976,10 @@ mono_class_create_runtime_vtable (MonoDomain *domain, MonoClass *klass, MonoErro
 	mono_domain_lock (domain);
 
 	runtime_info = m_class_get_runtime_info (klass);
-	if (runtime_info && runtime_info->max_domain >= domain->domain_id && runtime_info->domain_vtables [domain->domain_id]) {
+	if (runtime_info) {
 		mono_domain_unlock (domain);
 		mono_loader_unlock ();
-		vt = runtime_info->domain_vtables [domain->domain_id];
+		vt = runtime_info->domain_vtable;
 		goto exit;
 	}
 	if (!m_class_is_inited (klass) || mono_class_has_failure (klass)) {
@@ -2089,23 +2077,7 @@ mono_class_create_runtime_vtable (MonoDomain *domain, MonoClass *klass, MonoErro
 	MONO_PROFILER_RAISE (vtable_loading, (vt));
 
 	mono_class_compute_gc_descriptor (klass);
-	/*
-	 * For Boehm:
-	 * We can't use typed allocation in the non-root domains, since the
-	 * collector needs the GC descriptor stored in the vtable even after
-	 * the mempool containing the vtable is destroyed when the domain is
-	 * unloaded. An alternative might be to allocate vtables in the GC
-	 * heap, but this does not seem to work (it leads to crashes inside
-	 * libgc). If that approach is tried, two gc descriptors need to be
-	 * allocated for each class: one for the root domain, and one for all
-	 * other domains. The second descriptor should contain a bit for the
-	 * vtable field in MonoObject, since we can no longer assume the
-	 * vtable is reachable by other roots after the appdomain is unloaded.
-	 */
-	if (!mono_gc_is_moving () && domain != mono_get_root_domain () && !mono_dont_free_domains)
-		vt->gc_descr = MONO_GC_DESCRIPTOR_NULL;
-	else
-		vt->gc_descr = m_class_get_gc_descr (klass);
+	vt->gc_descr = m_class_get_gc_descr (klass);
 
 	gc_bits = mono_gc_get_vtable_bits (klass);
 	g_assert (!(gc_bits & ~((1 << MONO_VTABLE_AVAILABLE_GC_BITS) - 1)));
@@ -2272,7 +2244,7 @@ mono_class_create_runtime_vtable (MonoDomain *domain, MonoClass *klass, MonoErro
 	 */
 	mono_memory_barrier ();
 
-	mono_class_setup_runtime_info  (klass, domain, vt);
+	mono_class_setup_runtime_info (klass, vt);
 
 	if (klass == mono_defaults.runtimetype_class) {
 		MonoReflectionTypeHandle vt_type = mono_type_get_object_handle (domain, m_class_get_byval_arg (klass), error);
@@ -4215,10 +4187,6 @@ call_unhandled_exception_delegate (MonoDomain *domain, MonoObjectHandle delegate
 	MONO_REQ_GC_UNSAFE_MODE;
 
 	ERROR_DECL (error);
-	MonoDomain *current_domain = mono_domain_get ();
-
-	if (domain != current_domain)
-		mono_domain_set_internal_with_options (domain, FALSE);
 
 	g_assert (domain == mono_object_domain (domain->domain));
 
@@ -4231,9 +4199,6 @@ call_unhandled_exception_delegate (MonoDomain *domain, MonoObjectHandle delegate
 	mono_error_assert_ok (error);
 	mono_runtime_delegate_try_invoke_handle (delegate, pa, error);
 
-	if (domain != current_domain)
-		mono_domain_set_internal_with_options (current_domain, FALSE);
-
 	if (!is_ok (error)) {
 		g_warning ("exception inside UnhandledException handler: %s\n", mono_error_get_message (error));
 		mono_error_cleanup (error);
diff --git a/src/mono/mono/metadata/sgen-client-mono.h b/src/mono/mono/metadata/sgen-client-mono.h
index 211d9ed5549842..ecd79220895e53 100644
--- a/src/mono/mono/metadata/sgen-client-mono.h
+++ b/src/mono/mono/metadata/sgen-client-mono.h
@@ -725,6 +725,5 @@ gboolean sgen_has_managed_allocator (void);
 void sgen_disable_native_stack_scan (void);
 
 void sgen_scan_for_registered_roots_in_domain (MonoDomain *domain, int root_type);
-void sgen_null_links_for_domain (MonoDomain *domain);
 
 #endif
diff --git a/src/mono/mono/metadata/sgen-mono.c b/src/mono/mono/metadata/sgen-mono.c
index e586d8150a6cb7..22f5ec0e12d41f 100644
--- a/src/mono/mono/metadata/sgen-mono.c
+++ b/src/mono/mono/metadata/sgen-mono.c
@@ -826,81 +826,6 @@ sgen_finish_concurrent_work (const char *reason, gboolean stw)
 	sgen_major_collector.finish_sweeping ();
 }
 
-/*
- * When appdomains are unloaded we can easily remove objects that have finalizers,
- * but all the others could still be present in random places on the heap.
- * We need a sweep to get rid of them even though it's going to be costly
- * with big heaps.
- * The reason we need to remove them is because we access the vtable and class
- * structures to know the object size and the reference bitmap: once the domain is
- * unloaded the point to random memory.
- */
-void
-mono_gc_clear_domain (MonoDomain * domain)
-{
-	int i;
-
-	LOCK_GC;
-
-	sgen_binary_protocol_domain_unload_begin (domain);
-
-	sgen_stop_world (0, FALSE);
-
-	sgen_finish_concurrent_work ("clear domain", FALSE);
-
-	sgen_process_fin_stage_entries ();
-
-	sgen_clear_nursery_fragments ();
-
-	FOREACH_THREAD_ALL (info) {
-		mono_handle_stack_free_domain (info->client_info.info.handle_stack, domain);
-	} FOREACH_THREAD_END
-
-	if (sgen_mono_xdomain_checks && domain != mono_get_root_domain ()) {
-		sgen_scan_for_registered_roots_in_domain (domain, ROOT_TYPE_NORMAL);
-		sgen_scan_for_registered_roots_in_domain (domain, ROOT_TYPE_WBARRIER);
-		sgen_check_for_xdomain_refs ();
-	}
-
-	/*Ephemerons and dislinks must be processed before LOS since they might end up pointing
-	to memory returned to the OS.*/
-	null_ephemerons_for_domain (domain);
-	sgen_null_links_for_domain (domain);
-
-	for (i = GENERATION_NURSERY; i < GENERATION_MAX; ++i)
-		sgen_remove_finalizers_if (object_in_domain_predicate, domain, i);
-
-	sgen_scan_area_with_callback (sgen_nursery_section->data, sgen_nursery_section->end_data,
-			(IterateObjectCallbackFunc)clear_domain_process_minor_object_callback, domain, FALSE, TRUE);
-
-	/* We need two passes over major and large objects because
-	   freeing such objects might give their memory back to the OS
-	   (in the case of large objects) or obliterate its vtable
-	   (pinned objects with major-copying or pinned and non-pinned
-	   objects with major-mark&sweep), but we might need to
-	   dereference a pointer from an object to another object if
-	   the first object is a proxy. */
-	sgen_major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, (IterateObjectCallbackFunc)clear_domain_process_major_object_callback, domain);
-
-	sgen_los_iterate_objects ((IterateObjectCallbackFunc)clear_domain_process_los_object_callback, domain);
-	sgen_los_iterate_objects_free ((IterateObjectResultCallbackFunc)clear_domain_free_los_object_callback, domain);
-
-	sgen_major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_NON_PINNED, (IterateObjectCallbackFunc)clear_domain_free_major_non_pinned_object_callback, domain);
-	sgen_major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_PINNED, (IterateObjectCallbackFunc)clear_domain_free_major_pinned_object_callback, domain);
-
-	if (domain == mono_get_root_domain ()) {
-		sgen_pin_stats_report ();
-		sgen_object_layout_dump (stdout);
-	}
-
-	sgen_restart_world (0, FALSE);
-
-	sgen_binary_protocol_domain_unload_end (domain);
-	sgen_binary_protocol_flush_buffers (FALSE);
-
-	UNLOCK_GC;
-}
-
 /*
  * Allocation
  */
@@ -2737,8 +2662,7 @@ mono_gchandle_new_weakref_internal (GCObject *obj, gboolean track_resurrection)
 gboolean
 mono_gchandle_is_in_domain (MonoGCHandle gchandle, MonoDomain *domain)
 {
-	MonoDomain *gchandle_domain = (MonoDomain *)sgen_gchandle_get_metadata (MONO_GC_HANDLE_TO_UINT (gchandle));
-	return domain->domain_id == gchandle_domain->domain_id;
+	return TRUE;
 }
 
 /**
@@ -2783,31 +2707,6 @@ mono_gchandle_get_target_internal (MonoGCHandle gchandle)
 	return sgen_gchandle_get_target (MONO_GC_HANDLE_TO_UINT (gchandle));
 }
 
-static gpointer
-null_link_if_in_domain (gpointer hidden, GCHandleType handle_type, int max_generation, gpointer user)
-{
-	MonoDomain *unloading_domain = (MonoDomain *)user;
-	MonoDomain *obj_domain;
-	gboolean is_weak = MONO_GC_HANDLE_TYPE_IS_WEAK (handle_type);
-	if (MONO_GC_HANDLE_IS_OBJECT_POINTER (hidden)) {
-		MonoObject *obj = (MonoObject *)MONO_GC_REVEAL_POINTER (hidden, is_weak);
-		obj_domain = mono_object_domain (obj);
-	} else {
-		obj_domain = (MonoDomain *)MONO_GC_REVEAL_POINTER (hidden, is_weak);
-	}
-	if (unloading_domain->domain_id == obj_domain->domain_id)
-		return NULL;
-	return hidden;
-}
-
-void
-sgen_null_links_for_domain (MonoDomain *domain)
-{
-	guint type;
-	for (type = HANDLE_TYPE_MIN; type < HANDLE_TYPE_MAX; ++type)
-		sgen_gchandle_iterate ((GCHandleType)type, GENERATION_OLD, null_link_if_in_domain, domain);
-}
-
 void
 mono_gchandle_set_target (MonoGCHandle gchandle, MonoObject *obj)
 {
diff --git a/src/mono/mono/metadata/threads.c b/src/mono/mono/metadata/threads.c
index c8fea44c85979f..f5deaae070fdc7 100644
--- a/src/mono/mono/metadata/threads.c
+++ b/src/mono/mono/metadata/threads.c
@@ -810,9 +810,6 @@ mono_thread_attach_internal (MonoThread *thread, gboolean force_attach, gboolean
 
 	domain = mono_object_domain (thread);
 
-	if (!mono_domain_set_fast (domain, force_domain))
-		goto fail;
-
 	mono_threads_lock ();
 
 	if (shutting_down && !force_attach) {
@@ -967,13 +964,6 @@ mono_thread_detach_internal (MonoInternalThread *thread)
 	MONO_PROFILER_RAISE (gc_root_unregister, ((const mono_byte*)(info->stack_start_limit)));
 	MONO_PROFILER_RAISE (gc_root_unregister, ((const mono_byte*)(info->handle_stack)));
 
-	/*
-	 * This will signal async signal handlers that the thread has exited.
-	 * The profiler callback needs this to be set, so it cannot be done earlier.
-	 */
-	mono_domain_unset ();
-	mono_memory_barrier ();
-
 	mono_free_static_data (thread->static_data);
 	thread->static_data = NULL;
 
@@ -996,7 +986,6 @@ mono_thread_detach_internal (MonoInternalThread *thread)
 	mono_memory_barrier ();
 
 	SET_CURRENT_OBJECT (NULL);
-	mono_domain_unset ();
 
 	if (!mono_thread_info_try_get_internal_thread_gchandle (info, &gchandle))
 		g_error ("%s: failed to get gchandle, info = %p", __func__, info);
@@ -1484,8 +1473,6 @@ mono_thread_internal_attach (MonoDomain *domain)
 	MonoNativeThreadId tid;
 
 	if (mono_thread_internal_current_is_attached ()) {
-		if (domain != mono_domain_get ())
-			mono_domain_set_fast (domain, TRUE);
 		/* Already attached */
 		return mono_thread_current ();
 	}
@@ -5196,12 +5183,9 @@ mono_thread_internal_unhandled_exception (MonoObject* exc)
 MonoDomain*
 mono_threads_attach_coop_internal (MonoDomain *domain, gpointer *cookie, MonoStackData *stackdata)
 {
-	MonoDomain *orig;
 	MonoThreadInfo *info;
 	gboolean external = FALSE;
 
-	orig = mono_domain_get ();
-
 	if (!domain) {
 		/* Happens when called from AOTed code which is only used in the root domain. */
 		domain = mono_get_root_domain ();
@@ -5233,10 +5217,7 @@ mono_threads_attach_coop_internal (MonoDomain *domain, gpointer *cookie, MonoSta
 		}
 	}
 
-	if (orig != domain)
-		mono_domain_set_fast (domain, TRUE);
-
-	return orig;
+	return domain;
 }
 
 /*
@@ -5268,16 +5249,6 @@ mono_threads_attach_coop (MonoDomain *domain, gpointer *dummy)
 void
 mono_threads_detach_coop_internal (MonoDomain *orig, gpointer cookie, MonoStackData *stackdata)
 {
-	MonoDomain *domain = mono_domain_get ();
-	g_assert (domain);
-
-	if (orig != domain) {
-		if (!orig)
-			mono_domain_unset ();
-		else
-			mono_domain_set_fast (orig, TRUE);
-	}
-
 	if (mono_threads_is_blocking_transition_enabled ()) {
 		/* it won't do anything if cookie is NULL
 		 * thread state RUNNING -> (RUNNING|BLOCKING) */
diff --git a/src/mono/mono/mini/debugger-agent.c b/src/mono/mono/mini/debugger-agent.c
index 05dd82d13db27b..7c03fa008da910 100644
--- a/src/mono/mono/mini/debugger-agent.c
+++ b/src/mono/mono/mini/debugger-agent.c
@@ -3870,32 +3870,20 @@ send_type_load (MonoClass *klass)
 static void
 send_types_for_domain (MonoDomain *domain, void *user_data)
 {
-	MonoDomain* old_domain;
 	AgentDomainInfo *info = NULL;
 
 	info = get_agent_domain_info (domain);
 	g_assert (info);
 
-	old_domain = mono_domain_get ();
-
-	mono_domain_set_fast (domain, TRUE);
-	
 	mono_loader_lock ();
 	g_hash_table_foreach (info->loaded_classes, emit_type_load, NULL);
 	mono_loader_unlock ();
-
-	mono_domain_set_fast (old_domain, TRUE);
 }
 
 static void
 send_assemblies_for_domain (MonoDomain *domain, void *user_data)
 {
 	GSList *tmp;
-	MonoDomain* old_domain;
-
-	old_domain = mono_domain_get ();
-
-	mono_domain_set_fast (domain, TRUE);
 
 	mono_domain_assemblies_lock (domain);
 	for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
@@ -3903,8 +3891,6 @@ send_assemblies_for_domain (MonoDomain *domain, void *user_data)
 		emit_assembly_load (ass, NULL);
 	}
 	mono_domain_assemblies_unlock (domain);
-
-	mono_domain_set_fast (old_domain, TRUE);
 }
 
 static void
@@ -7304,13 +7290,8 @@ assembly_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 		gboolean ignorecase = decode_byte (p, &p, end);
 		MonoTypeNameParse info;
 		MonoType *t;
-		gboolean type_resolve, res;
-		MonoDomain *d = mono_domain_get ();
-		MonoAssemblyLoadContext *alc = mono_domain_default_alc (d);
-
-		/* This is needed to be able to find referenced assemblies */
-		res = mono_domain_set_fast (domain, FALSE);
-		g_assert (res);
+		gboolean type_resolve;
+		MonoAssemblyLoadContext *alc = mono_domain_default_alc (mono_domain_get ());
 
 		if (!mono_reflection_parse_type_checked (s, &info, error)) {
 			mono_error_cleanup (error);
@@ -7319,7 +7300,6 @@ assembly_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 			if (info.assembly.name) {
 				mono_reflection_free_type_info (&info);
 				g_free (s);
-				mono_domain_set_fast (d, TRUE);
 				char* error_msg =  g_strdup_printf ("Unexpected assembly-qualified type %s was provided", original_s);
 				add_error_string (buf, error_msg);
 				g_free (error_msg);
@@ -7331,7 +7311,6 @@ assembly_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 				mono_error_cleanup (error); /* FIXME don't swallow the error */
 				mono_reflection_free_type_info (&info);
 				g_free (s);
-				mono_domain_set_fast (d, TRUE);
 				char* error_msg =  g_strdup_printf ("Invalid type name %s", original_s);
 				add_error_string (buf, error_msg);
 				g_free (error_msg);
@@ -7343,7 +7322,6 @@ assembly_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 		mono_reflection_free_type_info (&info);
 		g_free (s);
 		g_free (original_s);
-		mono_domain_set_fast (d, TRUE);
 
 		break;
 	}
@@ -8051,7 +8029,6 @@ static ErrorCode
 type_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 {
 	MonoClass *klass;
-	MonoDomain *old_domain;
 	MonoDomain *domain;
 	ErrorCode err;
 
@@ -8059,14 +8036,8 @@ type_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 	if (err != ERR_NONE)
 		return err;
 
-	old_domain = mono_domain_get ();
-
-	mono_domain_set_fast (domain, TRUE);
-
 	err = type_commands_internal (command, klass, domain, p, end, buf);
 
-	mono_domain_set_fast (old_domain, TRUE);
-
 	return err;
 }
 
@@ -8526,7 +8497,6 @@ static ErrorCode
 method_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 {
 	ErrorCode err;
-	MonoDomain *old_domain;
 	MonoDomain *domain;
 	MonoMethod *method;
 
@@ -8534,14 +8504,8 @@ method_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 	if (err != ERR_NONE)
 		return err;
 
-	old_domain = mono_domain_get ();
-
-	mono_domain_set_fast (domain, TRUE);
-
 	err = method_commands_internal (command, method, domain, p, end, buf);
 
-	mono_domain_set_fast (old_domain, TRUE);
-
 	return err;
 }
 
diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c
index f38cfd9db0153e..1881aa961675bd 100644
--- a/src/mono/mono/mini/mini-runtime.c
+++ b/src/mono/mono/mini/mini-runtime.c
@@ -845,7 +845,6 @@ mono_pop_lmf (MonoLMF *lmf)
 MonoDomain*
 mono_jit_thread_attach (MonoDomain *domain)
 {
-	MonoDomain *orig;
 	gboolean attached;
 
 	if (!domain) {
@@ -872,11 +871,7 @@ mono_jit_thread_attach (MonoDomain *domain)
 		mono_threads_enter_gc_safe_region_unbalanced_internal (&stackdata);
 	}
 
-	orig = mono_domain_get ();
-	if (orig != domain)
-		mono_domain_set_fast (domain, TRUE);
-
-	return orig != domain ? orig : NULL;
+	return NULL;
 }
 
 /*
@@ -888,9 +883,6 @@ void
 mono_jit_set_domain (MonoDomain *domain)
 {
 	g_assert (!mono_threads_is_blocking_transition_enabled ());
-
-	if (domain)
-		mono_domain_set_fast (domain, TRUE);
 }
 
 /**
@@ -3907,8 +3899,6 @@ mini_parse_debug_option (const char *option)
 		mini_debug_options.suspend_on_exception = TRUE;
 	else if (!strcmp (option, "suspend-on-unhandled"))
 		mini_debug_options.suspend_on_unhandled = TRUE;
-	else if (!strcmp (option, "dont-free-domains"))
-		mono_dont_free_domains = TRUE;
 	else if (!strcmp (option, "dyn-runtime-invoke"))
 		mini_debug_options.dyn_runtime_invoke = TRUE;
 	else if (!strcmp (option, "gdb"))
@@ -3939,8 +3929,6 @@ mini_parse_debug_option (const char *option)
 		mini_debug_options.check_pinvoke_callconv = TRUE;
 	else if (!strcmp (option, "use-fallback-tls"))
 		mini_debug_options.use_fallback_tls = TRUE;
-	else if (!strcmp (option, "debug-domain-unload"))
-		g_error ("MONO_DEBUG option debug-domain-unload is deprecated.");
 	else if (!strcmp (option, "partial-sharing"))
 		mono_set_partial_sharing_supported (TRUE);
 	else if (!strcmp (option, "align-small-structs"))
@@ -4400,7 +4388,6 @@ mini_init (const char *filename, const char *runtime_version)
 
 	if (mini_debug_options.lldb || g_hasenv ("MONO_LLDB")) {
 		mono_lldb_init ("");
-		mono_dont_free_domains = TRUE;
 	}
 
 #ifdef XDEBUG_ENABLED
@@ -4408,12 +4395,9 @@ mini_init (const char *filename, const char *runtime_version)
 	if (mono_xdebug) {
 		mono_xdebug_init (mono_xdebug);
 		g_free (mono_xdebug);
-		/* So methods for multiple domains don't have the same address */
-		mono_dont_free_domains = TRUE;
 		mono_using_xdebug = TRUE;
 	} else if (mini_debug_options.gdb) {
 		mono_xdebug_init ((char*)"gdb");
-		mono_dont_free_domains = TRUE;
 		mono_using_xdebug = TRUE;
 	}
 #endif
@@ -4449,7 +4433,6 @@ mini_init (const char *filename, const char *runtime_version)
 
 #ifdef JIT_TRAMPOLINES_WORK
 	mono_install_create_domain_hook (mini_create_jit_domain_info);
-	mono_install_free_domain_hook (mini_free_jit_domain_info);
 #endif
 	mono_install_get_cached_class_info (mono_aot_get_cached_class_info);
 	mono_install_get_class_from_name (mono_aot_get_class_from_name);