diff --git a/aom_dsp/bitwriter.h b/aom_dsp/bitwriter.h
index e6118e8..1ad7538 100644
--- a/aom_dsp/bitwriter.h
+++ b/aom_dsp/bitwriter.h
@@ -39,15 +39,12 @@
 
 typedef struct TOKEN_STATS {
   int cost;
-#if CONFIG_VAR_TX
 #if CONFIG_RD_DEBUG
   int txb_coeff_cost_map[TXB_COEFF_COST_MAP_SIZE][TXB_COEFF_COST_MAP_SIZE];
 #endif
-#endif
 } TOKEN_STATS;
 
 static INLINE void init_token_stats(TOKEN_STATS *token_stats) {
-#if CONFIG_VAR_TX
 #if CONFIG_RD_DEBUG
   int r, c;
   for (r = 0; r < TXB_COEFF_COST_MAP_SIZE; ++r) {
@@ -56,7 +53,6 @@
     }
   }
 #endif
-#endif
   token_stats->cost = 0;
 }
 
diff --git a/av1/common/alloccommon.c b/av1/common/alloccommon.c
index 0bd26a7..ad994ae 100644
--- a/av1/common/alloccommon.c
+++ b/av1/common/alloccommon.c
@@ -201,7 +201,6 @@
   aom_free(cm->above_seg_context);
   cm->above_seg_context = NULL;
   cm->above_context_alloc_cols = 0;
-#if CONFIG_VAR_TX
   aom_free(cm->above_txfm_context);
   cm->above_txfm_context = NULL;
 
@@ -209,7 +208,6 @@
     aom_free(cm->top_txfm_context[i]);
     cm->top_txfm_context[i] = NULL;
   }
-#endif
 }
 
 int av1_alloc_context_buffers(AV1_COMMON *cm, int width, int height) {
@@ -250,7 +248,6 @@
         aligned_mi_cols, sizeof(*cm->above_seg_context));
     if (!cm->above_seg_context) goto fail;
 
-#if CONFIG_VAR_TX
     aom_free(cm->above_txfm_context);
     cm->above_txfm_context = (TXFM_CONTEXT *)aom_calloc(
         aligned_mi_cols << TX_UNIT_WIDE_LOG2, sizeof(*cm->above_txfm_context));
@@ -263,7 +260,6 @@
                                      sizeof(*cm->top_txfm_context[0]));
       if (!cm->top_txfm_context[i]) goto fail;
     }
-#endif
 
     cm->above_context_alloc_cols = aligned_mi_cols;
   }
diff --git a/av1/common/av1_loopfilter.c b/av1/common/av1_loopfilter.c
index 4dfc15f..611ef74 100644
--- a/av1/common/av1_loopfilter.c
+++ b/av1/common/av1_loopfilter.c
@@ -2139,7 +2139,6 @@
     const int r_step = (r >> ss_y);
     const int col_mask = 1 << c_step;
 
-#if CONFIG_VAR_TX
     if (is_inter_block(mbmi) && !mbmi->skip) {
       const int tx_row_idx =
           (blk_row * mi_size_high[BLOCK_8X8] << TX_UNIT_HIGH_LOG2) >> 1;
@@ -2156,7 +2155,6 @@
                     ? uv_txsize_lookup[bsize][mb_tx_size][0][0]
                     : mb_tx_size;
     }
-#endif
 
 // Filter level can vary per MI
 #if CONFIG_EXT_DELTA_Q
@@ -2176,7 +2174,6 @@
     if (!(lfl_r[c_step] = get_filter_level(&cm->lf_info, mbmi))) continue;
 #endif
 
-#if CONFIG_VAR_TX
     TX_SIZE tx_size_horz_edge, tx_size_vert_edge;
 
     // filt_len_vert_edge is the length of deblocking filter for a vertical edge
@@ -2212,15 +2209,6 @@
     memset(cm->left_txfm_context[pl] +
                (((mi_row + idx_r) & MAX_MIB_MASK) << TX_UNIT_HIGH_LOG2),
            tx_size, mi_size_high[BLOCK_8X8] << TX_UNIT_HIGH_LOG2);
-#else
-    // The length (or equally the square tx size) of deblocking filter is only
-    // determined by
-    // a) current block's width for a vertical deblocking edge
-    // b) current block's height for a horizontal deblocking edge
-    TX_SIZE tx_size_vert_edge = txsize_horz_map[tx_size];
-    TX_SIZE tx_size_horz_edge = txsize_vert_map[tx_size];
-    (void)pl;
-#endif  // CONFIG_VAR_TX
 
     if (tx_size_vert_edge == TX_32X32)
       tx_size_mask = 3;
@@ -2254,13 +2242,8 @@
           col_masks.m4x4 |= col_mask;
       }
 
-#if CONFIG_VAR_TX
       if (!skip_this && tx_wide_cur < 8 && !skip_border_4x4_c &&
           (c_step & tx_size_mask) == 0)
-#else
-      if (!skip_this && tx_size_vert_edge < TX_8X8 && !skip_border_4x4_c &&
-          (c_step & tx_size_mask) == 0)
-#endif  // CONFIG_VAR_TX
         mask_4x4_int_c |= col_mask;
     }
 
@@ -2295,13 +2278,8 @@
           row_masks.m4x4 |= col_mask;
       }
 
-#if CONFIG_VAR_TX
       if (!skip_this && tx_high_cur < 8 && !skip_border_4x4_r &&
           (r_step & tx_size_mask) == 0)
-#else
-      if (!skip_this && tx_size_horz_edge < TX_8X8 && !skip_border_4x4_r &&
-          (r_step & tx_size_mask) == 0)
-#endif  // CONFIG_VAR_TX
         mask_4x4_int_r |= col_mask;
     }
   }
@@ -2783,7 +2761,6 @@
                         : av1_get_uv_tx_size(mbmi, plane_ptr);
   assert(tx_size < TX_SIZES_ALL);
 
-#if CONFIG_VAR_TX
   // mi_row and mi_col is the absolute position of the MI block.
   // idx_c and idx_r is the relative offset of the MI within the super block
   // c and r is the relative offset of the 8x8 block within the supert block
@@ -2818,12 +2795,6 @@
                   : uv_txsize_lookup[bsize][mb_tx_size][0][0];
     assert(tx_size < TX_SIZES_ALL);
   }
-#else
-  (void)mi_row;
-  (void)mi_col;
-  (void)scale_horz;
-  (void)scale_vert;
-#endif  // CONFIG_VAR_TX
 
   // since in case of chrominance or non-square transorm need to convert
   // transform size into transform size in particular direction.
@@ -3468,17 +3439,13 @@
   int plane;
 
 #if !CONFIG_PARALLEL_DEBLOCKING
-#if CONFIG_VAR_TX
   for (int i = 0; i < MAX_MB_PLANE; ++i)
     memset(cm->top_txfm_context[i], TX_32X32, cm->mi_cols << TX_UNIT_WIDE_LOG2);
-#endif  // CONFIG_VAR_TX
   for (mi_row = start; mi_row < stop; mi_row += cm->mib_size) {
     MODE_INFO **mi = cm->mi_grid_visible + mi_row * cm->mi_stride;
-#if CONFIG_VAR_TX
     for (int i = 0; i < MAX_MB_PLANE; ++i)
       memset(cm->left_txfm_context[i], TX_32X32,
              MAX_MIB_SIZE << TX_UNIT_HIGH_LOG2);
-#endif  // CONFIG_VAR_TX
     for (mi_col = 0; mi_col < cm->mi_cols; mi_col += cm->mib_size) {
       av1_setup_dst_planes(planes, cm->sb_size, frame_buffer, mi_row, mi_col);
 
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 8d81604..27c668b 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -273,11 +273,9 @@
 } FILTER_INTRA_MODE_INFO;
 #endif  // CONFIG_FILTER_INTRA
 
-#if CONFIG_VAR_TX
 #if CONFIG_RD_DEBUG
 #define TXB_COEFF_COST_MAP_SIZE (2 * MAX_MIB_SIZE)
 #endif
-#endif
 
 typedef struct RD_STATS {
   int rate;
@@ -295,10 +293,8 @@
   uint8_t invalid_rate;
 #if CONFIG_RD_DEBUG
   int txb_coeff_cost[MAX_MB_PLANE];
-#if CONFIG_VAR_TX
   int txb_coeff_cost_map[MAX_MB_PLANE][TXB_COEFF_COST_MAP_SIZE]
                         [TXB_COEFF_COST_MAP_SIZE];
-#endif  // CONFIG_VAR_TX
 #endif  // CONFIG_RD_DEBUG
 } RD_STATS;
 
@@ -322,12 +318,10 @@
   BLOCK_SIZE sb_type;
   PREDICTION_MODE mode;
   TX_SIZE tx_size;
-#if CONFIG_VAR_TX
   // TODO(jingning): This effectively assigned a separate entry for each
   // 8x8 block. Apparently it takes much more space than needed.
   TX_SIZE inter_tx_size[MAX_MIB_SIZE][MAX_MIB_SIZE];
   TX_SIZE min_tx_size;
-#endif
   int8_t skip;
   int8_t segment_id;
   int8_t seg_id_predicted;  // valid only when temporal_update is enabled
@@ -709,11 +703,9 @@
   PARTITION_CONTEXT *above_seg_context;
   PARTITION_CONTEXT left_seg_context[MAX_MIB_SIZE];
 
-#if CONFIG_VAR_TX
   TXFM_CONTEXT *above_txfm_context;
   TXFM_CONTEXT *left_txfm_context;
   TXFM_CONTEXT left_txfm_context_buffer[2 * MAX_MIB_SIZE];
-#endif
 
 #if CONFIG_LOOP_RESTORATION
   WienerInfo wiener_info[MAX_MB_PLANE];
@@ -832,7 +824,7 @@
 #endif  // CONFIG_RECT_TX
 
 static INLINE int block_signals_txsize(BLOCK_SIZE bsize) {
-#if (CONFIG_VAR_TX || CONFIG_EXT_TX) && CONFIG_RECT_TX
+#if CONFIG_RECT_TX
   return bsize > BLOCK_4X4;
 #else
   return bsize >= BLOCK_8X8;
@@ -1081,7 +1073,7 @@
 #endif  // CONFIG_RECT_TX
 #endif  // CONFIG_EXT_TX
 
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
 static INLINE int is_quarter_tx_allowed_bsize(BLOCK_SIZE bsize) {
   static const char LUT_QTTX[BLOCK_SIZES_ALL] = {
 #if CONFIG_CHROMA_SUB8X8
@@ -1133,13 +1125,13 @@
 static INLINE TX_SIZE tx_size_from_tx_mode(BLOCK_SIZE bsize, TX_MODE tx_mode,
                                            int is_inter) {
   const TX_SIZE largest_tx_size = tx_mode_to_biggest_tx_size[tx_mode];
-#if (CONFIG_VAR_TX || CONFIG_EXT_TX) && CONFIG_RECT_TX
+#if CONFIG_RECT_TX
   const TX_SIZE max_rect_tx_size = max_txsize_rect_lookup[bsize];
 #else
   const TX_SIZE max_tx_size = max_txsize_lookup[bsize];
-#endif  // (CONFIG_VAR_TX || CONFIG_EXT_TX) && CONFIG_RECT_TX
+#endif  // CONFIG_RECT_TX
   (void)is_inter;
-#if CONFIG_VAR_TX && CONFIG_RECT_TX
+#if CONFIG_RECT_TX
   if (bsize == BLOCK_4X4)
     return AOMMIN(max_txsize_lookup[bsize], largest_tx_size);
   if (txsize_sqr_map[max_rect_tx_size] <= largest_tx_size)
@@ -1154,7 +1146,7 @@
   }
 #else
   return AOMMIN(max_tx_size, largest_tx_size);
-#endif  // CONFIG_VAR_TX && CONFIG_RECT_TX
+#endif  // CONFIG_RECT_TX
 }
 
 #if CONFIG_EXT_INTRA
@@ -1407,7 +1399,6 @@
   return (mbmi->ref_frame[1] == INTRA_FRAME) && is_interintra_allowed(mbmi);
 }
 
-#if CONFIG_VAR_TX
 static INLINE int get_vartx_max_txsize(const MB_MODE_INFO *const mbmi,
                                        BLOCK_SIZE bsize, int subsampled) {
   (void)mbmi;
@@ -1428,7 +1419,6 @@
 
   return max_txsize;
 }
-#endif  // CONFIG_VAR_TX
 
 #if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
 static INLINE int is_motion_variation_allowed_bsize(BLOCK_SIZE bsize) {
diff --git a/av1/common/common_data.h b/av1/common/common_data.h
index 2751bcc..522ac28 100644
--- a/av1/common/common_data.h
+++ b/av1/common/common_data.h
@@ -605,7 +605,7 @@
 #endif  // CONFIG_EXT_PARTITION
 };
 
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
 static const TX_SIZE max_txsize_rect_lookup[BLOCK_SIZES_ALL] = {
   // 2X2,    2X4,      4X2,
 #if   CONFIG_CHROMA_SUB8X8
@@ -689,7 +689,7 @@
 #endif
 #else
 #define max_txsize_rect_lookup max_txsize_lookup
-#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#endif  // CONFIG_RECT_TX
 
 static const TX_TYPE_1D vtx_tab[TX_TYPES] = {
   DCT_1D,      ADST_1D, DCT_1D,      ADST_1D,
@@ -707,7 +707,7 @@
 #endif  // CONFIG_EXT_TX
 };
 
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
 // Same as "max_txsize_lookup[bsize] - TX_8X8", except for rectangular
 // block which may use a rectangular transform, in which  case it is
 // "(max_txsize_lookup[bsize] + 1) - TX_8X8", invalid for bsize < 8X8
@@ -797,7 +797,7 @@
   TX_32X32 - TX_8X8,  TX_32X32 - TX_8X8
 #endif  // CONFIG_EXT_PARTITION
 };
-#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#endif  // CONFIG_RECT_TX
 
 #define inter_tx_size_cat_lookup intra_tx_size_cat_lookup
 
diff --git a/av1/common/entropy.c b/av1/common/entropy.c
index 3209d3c..33c53fb 100644
--- a/av1/common/entropy.c
+++ b/av1/common/entropy.c
@@ -2319,9 +2319,7 @@
 
 #if CONFIG_NEW_MULTISYMBOL
   AVERAGE_TILE_CDFS(skip_cdfs)
-#if CONFIG_VAR_TX
   AVERAGE_TILE_CDFS(txfm_partition_cdf)
-#endif
 #endif  // CONFIG_NEW_MULTISYMBOL
   AVERAGE_TILE_CDFS(palette_y_size_cdf)
   AVERAGE_TILE_CDFS(palette_uv_size_cdf)
@@ -2333,7 +2331,7 @@
 #if CONFIG_NEW_MULTISYMBOL
   AVERAGE_TILE_CDFS(palette_y_mode_cdf)
   AVERAGE_TILE_CDFS(palette_uv_mode_cdf)
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
   AVERAGE_TILE_CDFS(quarter_tx_size_cdf)
 #endif
 #endif
diff --git a/av1/common/entropy.h b/av1/common/entropy.h
index 497d4c2..ce9e406 100644
--- a/av1/common/entropy.h
+++ b/av1/common/entropy.h
@@ -324,7 +324,7 @@
       left_ec = !!*(const uint64_t *)l;
       break;
 #endif  // CONFIG_TX64X64
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
     case TX_4X16:
       above_ec = a[0] != 0;
       left_ec = !!*(const uint32_t *)l;
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index 52a3e0c..43d414b 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -2283,7 +2283,7 @@
                                                     1] = { -1, -1, 0, -1, -1,
                                                            4,  3,  2, 1 };
 
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
 static const aom_prob default_quarter_tx_size_prob = 192;
 #if CONFIG_NEW_MULTISYMBOL
 static const aom_cdf_prob default_quarter_tx_size_cdf[CDF_SIZE(2)] = {
@@ -2393,7 +2393,6 @@
 #undef NUM_PALETTE_NEIGHBORS
 #undef MAX_COLOR_CONTEXT_HASH
 
-#if CONFIG_VAR_TX
 static const aom_prob default_txfm_partition_probs[TXFM_PARTITION_CONTEXTS] = {
 #if CONFIG_TX64X64
   249, 240, 223, 249, 229, 177, 250, 243, 208, 226, 187,
@@ -2448,7 +2447,6 @@
 #endif  // CONFIG_TX64X64
     };
 #endif  // CONFIG_NEW_MULTISYMBOL
-#endif  // CONFIG_VAR_TX
 
 #if CONFIG_NEW_MULTISYMBOL
 static const aom_cdf_prob default_skip_cdfs[SKIP_CONTEXTS][CDF_SIZE(2)] = {
@@ -6265,18 +6263,16 @@
 #if CONFIG_COMPOUND_SINGLEREF
   av1_copy(fc->comp_inter_mode_prob, default_comp_inter_mode_p);
 #endif  // CONFIG_COMPOUND_SINGLEREF
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
   fc->quarter_tx_size_prob = default_quarter_tx_size_prob;
 #if CONFIG_NEW_MULTISYMBOL
   av1_copy(fc->quarter_tx_size_cdf, default_quarter_tx_size_cdf);
 #endif  // CONFIG_NEW_MULTISYMBOL
 #endif
-#if CONFIG_VAR_TX
   av1_copy(fc->txfm_partition_prob, default_txfm_partition_probs);
 #if CONFIG_NEW_MULTISYMBOL
   av1_copy(fc->txfm_partition_cdf, default_txfm_partition_cdf);
 #endif
-#endif
   av1_copy(fc->newmv_prob, default_newmv_prob);
   av1_copy(fc->zeromv_prob, default_zeromv_prob);
   av1_copy(fc->refmv_prob, default_refmv_prob);
@@ -6517,19 +6513,17 @@
   const FRAME_COUNTS *counts = &cm->counts;
 
   if (cm->tx_mode == TX_MODE_SELECT) {
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
     fc->quarter_tx_size_prob = av1_mode_mv_merge_probs(
         pre_fc->quarter_tx_size_prob, counts->quarter_tx_size);
 #endif
   }
 
-#if CONFIG_VAR_TX
   if (cm->tx_mode == TX_MODE_SELECT) {
     for (i = 0; i < TXFM_PARTITION_CONTEXTS; ++i)
       fc->txfm_partition_prob[i] = av1_mode_mv_merge_probs(
           pre_fc->txfm_partition_prob[i], counts->txfm_partition[i]);
   }
-#endif
 
 #if !CONFIG_NEW_MULTISYMBOL
   for (i = 0; i < SKIP_CONTEXTS; ++i)
diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index c59a2a2..c534679 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h
@@ -285,18 +285,16 @@
 #if CONFIG_COMPOUND_SINGLEREF
   aom_prob comp_inter_mode_prob[COMP_INTER_MODE_CONTEXTS];
 #endif  // CONFIG_COMPOUND_SINGLEREF
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
   aom_prob quarter_tx_size_prob;
 #if CONFIG_NEW_MULTISYMBOL
   aom_cdf_prob quarter_tx_size_cdf[CDF_SIZE(2)];
 #endif
 #endif
-#if CONFIG_VAR_TX
   aom_prob txfm_partition_prob[TXFM_PARTITION_CONTEXTS];
 #if CONFIG_NEW_MULTISYMBOL
   aom_cdf_prob txfm_partition_cdf[TXFM_PARTITION_CONTEXTS][CDF_SIZE(2)];
 #endif
-#endif  // CONFIG_VAR_TX
 #if CONFIG_NEW_MULTISYMBOL
   aom_cdf_prob skip_cdfs[SKIP_CONTEXTS][CDF_SIZE(2)];
   aom_cdf_prob intra_inter_cdf[INTRA_INTER_CONTEXTS][CDF_SIZE(2)];
@@ -477,12 +475,10 @@
   // TODO(urvang): Only needed for !CONFIG_VAR_TX case. So can be removed when
   // CONFIG_VAR_TX flag is removed.
   unsigned int tx_size[MAX_TX_DEPTH][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
   unsigned int quarter_tx_size[2];
 #endif
-#if CONFIG_VAR_TX
   unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
-#endif
   unsigned int skip[SKIP_CONTEXTS][2];
   nmv_context_counts mv[NMV_CONTEXTS];
 #if CONFIG_INTRABC
diff --git a/av1/common/enums.h b/av1/common/enums.h
index a93d05c..2ccd9e2 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -72,11 +72,9 @@
 #endif
 #endif  // CONFIG_EXT_TILE
 
-#if CONFIG_VAR_TX
 #define MAX_VARTX_DEPTH 2
 #define SQR_VARTX_DEPTH_INIT 0
 #define RECT_VARTX_DEPTH_INIT 0
-#endif
 
 #define MI_SIZE_64X64 (64 >> MI_SIZE_LOG2)
 
@@ -673,10 +671,8 @@
 #define COMP_INTER_MODE_CONTEXTS 4
 #endif  // CONFIG_COMPOUND_SINGLEREF
 
-#if CONFIG_VAR_TX
 #define TXFM_PARTITION_CONTEXTS ((TX_SIZES - TX_8X8) * 6 - 2)
 typedef uint8_t TXFM_CONTEXT;
-#endif
 
 #define NONE_FRAME -1
 #define INTRA_FRAME 0
diff --git a/av1/common/idct.c b/av1/common/idct.c
index 90c6141..7bd8302 100644
--- a/av1/common/idct.c
+++ b/av1/common/idct.c
@@ -2629,7 +2629,7 @@
 }
 
 // These will be used by the masked-tx experiment in the future.
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
 static void inv_txfm_add_4x16(const tran_low_t *input, uint8_t *dest,
                               int stride, const TxfmParam *txfm_param) {
 #if CONFIG_LGT
@@ -3189,7 +3189,7 @@
       // case.
       inv_txfm_add_4x4(input, dest, stride, txfm_param);
       break;
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
     case TX_32X8: inv_txfm_add_32x8(input, dest, stride, txfm_param); break;
     case TX_8X32: inv_txfm_add_8x32(input, dest, stride, txfm_param); break;
     case TX_16X4: inv_txfm_add_16x4(input, dest, stride, txfm_param); break;
diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index 6cf8a08..dbfbd94 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -462,11 +462,9 @@
 
   PARTITION_CONTEXT *above_seg_context;
   ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
-#if CONFIG_VAR_TX
   TXFM_CONTEXT *above_txfm_context;
   TXFM_CONTEXT *top_txfm_context[MAX_MB_PLANE];
   TXFM_CONTEXT left_txfm_context[MAX_MB_PLANE][2 * MAX_MIB_SIZE];
-#endif
   int above_context_alloc_cols;
 
   // scratch memory for intraonly/keyframe forward updates from default tables
@@ -716,9 +714,7 @@
   }
   xd->fc = cm->fc;
   xd->above_seg_context = cm->above_seg_context;
-#if CONFIG_VAR_TX
   xd->above_txfm_context = cm->above_txfm_context;
-#endif
 #if CONFIG_CFL
   cfl_init(cfl, cm);
   xd->cfl = cfl;
@@ -1142,18 +1138,14 @@
 
   av1_zero_array(cm->above_seg_context + mi_col_start, aligned_width);
 
-#if CONFIG_VAR_TX
   av1_zero_array(cm->above_txfm_context + (mi_col_start << TX_UNIT_WIDE_LOG2),
                  aligned_width << TX_UNIT_WIDE_LOG2);
-#endif  // CONFIG_VAR_TX
 }
 
 static INLINE void av1_zero_left_context(MACROBLOCKD *const xd) {
   av1_zero(xd->left_context);
   av1_zero(xd->left_seg_context);
-#if CONFIG_VAR_TX
   av1_zero(xd->left_txfm_context_buffer);
-#endif
 }
 
 // Disable array-bounds checks as the TX_SIZE enum contains values larger than
@@ -1171,7 +1163,6 @@
 #pragma GCC diagnostic warning "-Warray-bounds"
 #endif
 
-#if CONFIG_VAR_TX
 static INLINE void set_txfm_ctx(TXFM_CONTEXT *txfm_ctx, uint8_t txs, int len) {
   int i;
   for (i = 0; i < len; ++i) txfm_ctx[i] = txs;
@@ -1245,7 +1236,6 @@
   if (category == TXFM_PARTITION_CONTEXTS - 1) return category;
   return category * 3 + above + left;
 }
-#endif
 
 // Compute the next partition in the direction of the sb_type stored in the mi
 // array, starting with bsize.
diff --git a/av1/common/reconintra.c b/av1/common/reconintra.c
index f06bb3d..a6d8efa 100644
--- a/av1/common/reconintra.c
+++ b/av1/common/reconintra.c
@@ -45,8 +45,7 @@
 #endif  // CONFIG_INTRA_EDGE
 
 #define INTRA_USES_EXT_TRANSFORMS 1
-#define INTRA_USES_RECT_TRANSFORMS \
-  (CONFIG_RECT_TX && (CONFIG_VAR_TX || CONFIG_EXT_TX))
+#define INTRA_USES_RECT_TRANSFORMS (CONFIG_RECT_TX)
 
 static const uint8_t extend_modes[INTRA_MODES] = {
   NEED_ABOVE | NEED_LEFT,                   // DC
diff --git a/av1/common/scan.c b/av1/common/scan.c
index 8abe035..7d7c889 100644
--- a/av1/common/scan.c
+++ b/av1/common/scan.c
@@ -7869,14 +7869,14 @@
     case TX_8X8: return fc->non_zero_prob_8X8[tx_type];
     case TX_16X16: return fc->non_zero_prob_16X16[tx_type];
     case TX_32X32: return fc->non_zero_prob_32X32[tx_type];
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
     case TX_4X8: return fc->non_zero_prob_4X8[tx_type];
     case TX_8X4: return fc->non_zero_prob_8X4[tx_type];
     case TX_8X16: return fc->non_zero_prob_8X16[tx_type];
     case TX_16X8: return fc->non_zero_prob_16X8[tx_type];
     case TX_16X32: return fc->non_zero_prob_16X32[tx_type];
     case TX_32X16: return fc->non_zero_prob_32X16[tx_type];
-#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#endif  // CONFIG_RECT_TX
     default: assert(0); return NULL;
   }
 }
@@ -7888,14 +7888,14 @@
     case TX_8X8: return fc->scan_8X8[tx_type];
     case TX_16X16: return fc->scan_16X16[tx_type];
     case TX_32X32: return fc->scan_32X32[tx_type];
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
     case TX_4X8: return fc->scan_4X8[tx_type];
     case TX_8X4: return fc->scan_8X4[tx_type];
     case TX_8X16: return fc->scan_8X16[tx_type];
     case TX_16X8: return fc->scan_16X8[tx_type];
     case TX_16X32: return fc->scan_16X32[tx_type];
     case TX_32X16: return fc->scan_32X16[tx_type];
-#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#endif  // CONFIG_RECT_TX
     default: assert(0); return NULL;
   }
 }
@@ -7907,14 +7907,14 @@
     case TX_8X8: return fc->iscan_8X8[tx_type];
     case TX_16X16: return fc->iscan_16X16[tx_type];
     case TX_32X32: return fc->iscan_32X32[tx_type];
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
     case TX_4X8: return fc->iscan_4X8[tx_type];
     case TX_8X4: return fc->iscan_8X4[tx_type];
     case TX_8X16: return fc->iscan_8X16[tx_type];
     case TX_16X8: return fc->iscan_16X8[tx_type];
     case TX_16X32: return fc->iscan_16X32[tx_type];
     case TX_32X16: return fc->iscan_32X16[tx_type];
-#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#endif  // CONFIG_RECT_TX
     default: assert(0); return NULL;
   }
 }
@@ -7926,14 +7926,14 @@
     case TX_8X8: return fc->nb_8X8[tx_type];
     case TX_16X16: return fc->nb_16X16[tx_type];
     case TX_32X32: return fc->nb_32X32[tx_type];
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
     case TX_4X8: return fc->nb_4X8[tx_type];
     case TX_8X4: return fc->nb_8X4[tx_type];
     case TX_8X16: return fc->nb_8X16[tx_type];
     case TX_16X8: return fc->nb_16X8[tx_type];
     case TX_16X32: return fc->nb_16X32[tx_type];
     case TX_32X16: return fc->nb_32X16[tx_type];
-#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#endif  // CONFIG_RECT_TX
     default: assert(0); return NULL;
   }
 }
@@ -7945,14 +7945,14 @@
     case TX_8X8: return counts->non_zero_count_8X8[tx_type];
     case TX_16X16: return counts->non_zero_count_16X16[tx_type];
     case TX_32X32: return counts->non_zero_count_32X32[tx_type];
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
     case TX_4X8: return counts->non_zero_count_4x8[tx_type];
     case TX_8X4: return counts->non_zero_count_8x4[tx_type];
     case TX_8X16: return counts->non_zero_count_8x16[tx_type];
     case TX_16X8: return counts->non_zero_count_16x8[tx_type];
     case TX_16X32: return counts->non_zero_count_16x32[tx_type];
     case TX_32X16: return counts->non_zero_count_32x16[tx_type];
-#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#endif  // CONFIG_RECT_TX
     default: assert(0); return NULL;
   }
 }
@@ -8449,11 +8449,11 @@
   TX_SIZE tx_size;
   TX_TYPE tx_type;
   for (tx_size = 0; tx_size < TX_SIZES_ALL; ++tx_size) {
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
     if (tx_size > TX_32X16) continue;
 #else
     if (tx_size >= TX_SIZES) continue;
-#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#endif  // CONFIG_RECT_TX
     for (tx_type = DCT_DCT; tx_type < TX_TYPES; ++tx_type) {
       if (do_adapt_scan(tx_size, tx_type)) {
         uint32_t *non_zero_prob = get_non_zero_prob(cm->fc, tx_size, tx_type);
@@ -8484,11 +8484,11 @@
 #endif  // CACHE_SCAN_PROB
 
     for (tx_size = 0; tx_size < TX_SIZES_ALL; ++tx_size) {
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
       if (tx_size > TX_32X16) continue;
 #else
       if (tx_size >= TX_SIZES) continue;
-#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#endif  // CONFIG_RECT_TX
       TX_TYPE tx_type;
       for (tx_type = DCT_DCT; tx_type < TX_TYPES; ++tx_type) {
         if (do_adapt_scan(tx_size, tx_type)) {
diff --git a/av1/common/scan.h b/av1/common/scan.h
index 82d2e91..827a34f 100644
--- a/av1/common/scan.h
+++ b/av1/common/scan.h
@@ -82,13 +82,8 @@
 static INLINE const SCAN_ORDER *get_default_scan(TX_SIZE tx_size,
                                                  TX_TYPE tx_type,
                                                  int is_inter) {
-#if CONFIG_EXT_TX || CONFIG_VAR_TX
   return is_inter ? &av1_inter_scan_orders[tx_size][tx_type]
                   : &av1_intra_scan_orders[tx_size][tx_type];
-#else
-  (void)is_inter;
-  return &av1_intra_scan_orders[tx_size][tx_type];
-#endif  // CONFIG_EXT_TX
 }
 
 static INLINE int do_adapt_scan(TX_SIZE tx_size, TX_TYPE tx_type) {
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 4c8b9f6..65fa0da 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -313,7 +313,7 @@
 #endif  // CONFIG_CFL
 }
 
-#if CONFIG_VAR_TX && !CONFIG_COEF_INTERLEAVE
+#if !CONFIG_COEF_INTERLEAVE
 static void decode_reconstruct_tx(AV1_COMMON *cm, MACROBLOCKD *const xd,
                                   aom_reader *r, MB_MODE_INFO *const mbmi,
                                   int plane, BLOCK_SIZE plane_bsize,
@@ -398,10 +398,9 @@
     }
   }
 }
-#endif  // CONFIG_VAR_TX
+#endif
 
-#if !CONFIG_VAR_TX || CONFIG_COEF_INTERLEAVE || \
-    (!CONFIG_VAR_TX && CONFIG_EXT_TX && CONFIG_RECT_TX)
+#if CONFIG_COEF_INTERLEAVE || (!CONFIG_EXT_TX && CONFIG_RECT_TX)
 static int reconstruct_inter_block(AV1_COMMON *cm, MACROBLOCKD *const xd,
                                    aom_reader *const r, int segment_id,
                                    int plane, int row, int col,
@@ -441,7 +440,7 @@
 
   return eob;
 }
-#endif  // !CONFIG_VAR_TX || CONFIG_SUPER_TX
+#endif  // CONFIG_SUPER_TX
 
 static void set_offsets(AV1_COMMON *const cm, MACROBLOCKD *const xd,
                         BLOCK_SIZE bsize, int mi_row, int mi_col, int bw,
@@ -888,7 +887,6 @@
         mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
         mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
 
-#if CONFIG_VAR_TX
         const TX_SIZE max_tx_size = get_vartx_max_txsize(
             mbmi, plane_bsize, pd->subsampling_x || pd->subsampling_y);
         const int bh_var_tx = tx_size_high_unit[max_tx_size];
@@ -914,26 +912,6 @@
             }
           }
         }
-#else
-        const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
-        const int stepr = tx_size_high_unit[tx_size];
-        const int stepc = tx_size_wide_unit[tx_size];
-
-        for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
-          const int unit_height = AOMMIN(mu_blocks_high + row, max_blocks_high);
-          for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
-            int blk_row, blk_col;
-            const int unit_width =
-                AOMMIN(mu_blocks_wide + col, max_blocks_wide);
-
-            for (blk_row = row; blk_row < unit_height; blk_row += stepr)
-              for (blk_col = col; blk_col < unit_width; blk_col += stepc)
-                eobtotal +=
-                    reconstruct_inter_block(cm, xd, r, mbmi->segment_id, plane,
-                                            blk_row, blk_col, tx_size);
-          }
-        }
-#endif  // CONFIG_VAR_TX
       }
     }
   }
@@ -3520,8 +3498,7 @@
   AV1_COMMON *const cm = &pbi->common;
   aom_reader r;
 
-#if ((CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)) || \
-     (!CONFIG_NEW_MULTISYMBOL || CONFIG_LV_MAP) ||               \
+#if ((CONFIG_RECT_TX_EXT) || (!CONFIG_NEW_MULTISYMBOL || CONFIG_LV_MAP) || \
      (CONFIG_COMPOUND_SINGLEREF))
   FRAME_CONTEXT *const fc = cm->fc;
 #endif
@@ -3534,7 +3511,7 @@
     aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
                        "Failed to allocate bool decoder 0");
 
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
   if (cm->tx_mode == TX_MODE_SELECT)
     av1_diff_update_prob(&r, &fc->quarter_tx_size_prob, ACCT_STR);
 #endif
@@ -3544,11 +3521,9 @@
 #endif  // CONFIG_LV_MAP && !LV_MAP_PROB
 
 #if !CONFIG_NEW_MULTISYMBOL
-#if CONFIG_VAR_TX
   if (cm->tx_mode == TX_MODE_SELECT)
     for (int i = 0; i < TXFM_PARTITION_CONTEXTS; ++i)
       av1_diff_update_prob(&r, &fc->txfm_partition_prob[i], ACCT_STR);
-#endif  // CONFIG_VAR_TX
   for (int i = 0; i < SKIP_CONTEXTS; ++i)
     av1_diff_update_prob(&r, &fc->skip_probs[i], ACCT_STR);
 #endif
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 2f50acd..995dca7 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -390,7 +390,6 @@
   return aom_read_symbol(r, segp->tree_cdf, MAX_SEGMENTS, ACCT_STR);
 }
 
-#if CONFIG_VAR_TX
 static void read_tx_size_vartx(AV1_COMMON *cm, MACROBLOCKD *xd,
                                MB_MODE_INFO *mbmi, FRAME_COUNTS *counts,
                                TX_SIZE tx_size, int depth, int blk_row,
@@ -472,7 +471,6 @@
                           xd->left_txfm_context + blk_row, tx_size, tx_size);
   }
 }
-#endif
 
 static TX_SIZE read_selected_tx_size(AV1_COMMON *cm, MACROBLOCKD *xd,
                                      int32_t tx_size_cat, aom_reader *r) {
@@ -503,7 +501,7 @@
                                            : intra_tx_size_cat_lookup[bsize];
       const TX_SIZE coded_tx_size =
           read_selected_tx_size(cm, xd, tx_size_cat, r);
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
       if (coded_tx_size > max_txsize_lookup[bsize]) {
         assert(coded_tx_size == max_txsize_lookup[bsize] + 1);
 #if CONFIG_RECT_TX_EXT
@@ -531,7 +529,7 @@
       }
 #else
       assert(coded_tx_size <= max_txsize_lookup[bsize]);
-#endif  // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#endif  // CONFIG_RECT_TX
       return coded_tx_size;
     } else {
       return tx_size_from_tx_mode(bsize, tx_mode, is_inter);
@@ -936,11 +934,7 @@
   MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
   const int inter_block = is_inter_block(mbmi);
 #if !CONFIG_TXK_SEL
-#if CONFIG_VAR_TX
   const TX_SIZE tx_size = inter_block ? mbmi->min_tx_size : mbmi->tx_size;
-#else
-  const TX_SIZE tx_size = mbmi->tx_size;
-#endif
 #endif  // !CONFIG_TXK_SEL
   FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
 
@@ -1114,7 +1108,6 @@
   FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
   mbmi->use_intrabc = aom_read_symbol(r, ec_ctx->intrabc_cdf, 2, ACCT_STR);
   if (mbmi->use_intrabc) {
-#if CONFIG_VAR_TX
     const BLOCK_SIZE bsize = mbmi->sb_type;
     const int width = block_size_wide[bsize] >> tx_size_wide_log2[0];
     const int height = block_size_high[bsize] >> tx_size_high_log2[0];
@@ -1141,9 +1134,6 @@
       mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
       set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, mbmi->skip, xd);
     }
-#else
-    mbmi->tx_size = read_tx_size(cm, xd, 1, !mbmi->skip, r);
-#endif  // CONFIG_VAR_TX
     mbmi->mode = mbmi->uv_mode = UV_DC_PRED;
     mbmi->interp_filters = av1_broadcast_interp_filter(BILINEAR);
 
@@ -1231,14 +1221,12 @@
   mbmi->ref_frame[1] = NONE_FRAME;
 
 #if CONFIG_INTRABC
-#if CONFIG_VAR_TX
   if (cm->allow_screen_content_tools) {
     xd->above_txfm_context =
         cm->above_txfm_context + (mi_col << TX_UNIT_WIDE_LOG2);
     xd->left_txfm_context = xd->left_txfm_context_buffer +
                             ((mi_row & MAX_MIB_MASK) << TX_UNIT_HIGH_LOG2);
   }
-#endif  // CONFIG_VAR_TX
   if (av1_allow_intrabc(bsize, cm)) {
     read_intrabc_info(cm, xd, mi_row, mi_col, r);
     if (is_intrabc_block(mbmi)) return;
@@ -1246,10 +1234,10 @@
 #endif  // CONFIG_INTRABC
 
   mbmi->tx_size = read_tx_size(cm, xd, 0, 1, r);
-#if CONFIG_INTRABC && CONFIG_VAR_TX
+#if CONFIG_INTRABC
   if (cm->allow_screen_content_tools)
     set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, mbmi->skip, xd);
-#endif  // CONFIG_INTRABC && CONFIG_VAR_TX
+#endif  // CONFIG_INTRABC
 
   (void)i;
   mbmi->mode =
@@ -2690,9 +2678,7 @@
   MODE_INFO *const mi = xd->mi[0];
   MB_MODE_INFO *const mbmi = &mi->mbmi;
   int inter_block = 1;
-#if CONFIG_VAR_TX
   BLOCK_SIZE bsize = mbmi->sb_type;
-#endif  // CONFIG_VAR_TX
 
   mbmi->mv[0].as_int = 0;
   mbmi->mv[1].as_int = 0;
@@ -2739,7 +2725,6 @@
 
   inter_block = read_is_inter_block(cm, xd, mbmi->segment_id, r);
 
-#if CONFIG_VAR_TX
   xd->above_txfm_context =
       cm->above_txfm_context + (mi_col << TX_UNIT_WIDE_LOG2);
   xd->left_txfm_context = xd->left_txfm_context_buffer +
@@ -2800,9 +2785,6 @@
     mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
     set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, mbmi->skip, xd);
   }
-#else
-  mbmi->tx_size = read_tx_size(cm, xd, inter_block, !mbmi->skip, r);
-#endif  // CONFIG_VAR_TX
 
   if (inter_block)
     read_inter_block_mode_info(pbi, xd, mi, mi_row, mi_col, r);
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index db109e9..58b8fb4 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -244,7 +244,6 @@
   aom_wb_write_literal(wb, data, get_unsigned_bits(max));
 }
 
-#if CONFIG_VAR_TX
 static void write_tx_size_vartx(const AV1_COMMON *cm, MACROBLOCKD *xd,
                                 const MB_MODE_INFO *mbmi, TX_SIZE tx_size,
                                 int depth, int blk_row, int blk_col,
@@ -321,7 +320,6 @@
                               counts->txfm_partition[k], probwt);
 }
 #endif  // CONFIG_NEW_MULTISYMBOL
-#endif  // CONFIG_VAR_TX
 
 static void write_selected_tx_size(const AV1_COMMON *cm, const MACROBLOCKD *xd,
                                    aom_writer *w) {
@@ -343,7 +341,7 @@
 
     aom_write_symbol(w, depth, ec_ctx->tx_size_cdf[tx_size_cat][tx_size_ctx],
                      tx_size_cat + 2);
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
     if (is_quarter_tx_allowed(xd, mbmi, is_inter) && tx_size != coded_tx_size)
 #if CONFIG_NEW_MULTISYMBOL
       aom_write_symbol(w, tx_size == quarter_txsize_lookup[bsize],
@@ -597,10 +595,8 @@
 #endif  // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK
                            TOKEN_STATS *token_stats) {
   const TOKENEXTRA *p = *tp;
-#if CONFIG_VAR_TX
   int count = 0;
   const int seg_eob = tx_size_2d[tx_size];
-#endif
 
 #if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK
   if (tx_type == MRC_DCT && ((is_inter && SIGNAL_MRC_MASK_INTER) ||
@@ -619,9 +615,7 @@
     if (token == BLOCK_Z_TOKEN) {
       aom_write_symbol(w, 0, *p->head_cdf, HEAD_TOKENS + 1);
       p++;
-#if CONFIG_VAR_TX
       break;
-#endif
       continue;
     }
 
@@ -662,17 +656,15 @@
     }
     ++p;
 
-#if CONFIG_VAR_TX
     ++count;
     if (eob_val == EARLY_EOB || count == seg_eob) break;
-#endif
   }
 
   *tp = p;
 }
 #endif  // !CONFIG_LV_MAP
 
-#if CONFIG_VAR_TX && !CONFIG_COEF_INTERLEAVE
+#if !CONFIG_COEF_INTERLEAVE
 #if CONFIG_LV_MAP
 static void pack_txb_tokens(aom_writer *w,
 #if CONFIG_LV_MAP
@@ -816,7 +808,7 @@
   }
 }
 #endif  // CONFIG_LV_MAP
-#endif  // CONFIG_VAR_TX
+#endif
 
 static void write_segment_id(aom_writer *w, const struct segmentation *seg,
                              struct segmentation_probs *segp, int segment_id) {
@@ -1355,11 +1347,7 @@
   MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
   const int is_inter = is_inter_block(mbmi);
 #if !CONFIG_TXK_SEL
-#if CONFIG_VAR_TX
   const TX_SIZE tx_size = is_inter ? mbmi->min_tx_size : mbmi->tx_size;
-#else
-  const TX_SIZE tx_size = mbmi->tx_size;
-#endif  // CONFIG_VAR_TX
 #endif  // !CONFIG_TXK_SEL
   FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
 
@@ -1576,7 +1564,6 @@
 
   if (cm->tx_mode == TX_MODE_SELECT && block_signals_txsize(bsize) &&
       !(is_inter && skip) && !xd->lossless[segment_id]) {
-#if CONFIG_VAR_TX
     if (is_inter) {  // This implies skip flag is 0.
       const TX_SIZE max_tx_size = get_vartx_max_txsize(mbmi, bsize, 0);
       const int bh = tx_size_high_unit[max_tx_size];
@@ -1610,9 +1597,6 @@
     }
   } else {
     set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, skip, xd);
-#else
-    write_selected_tx_size(cm, xd, w);
-#endif
   }
 
   if (!is_inter) {
@@ -1829,7 +1813,6 @@
     assert(mbmi->mode == DC_PRED);
     assert(mbmi->uv_mode == UV_DC_PRED);
     if ((enable_tx_size && !mbmi->skip)) {
-#if CONFIG_VAR_TX
       const BLOCK_SIZE bsize = mbmi->sb_type;
       const TX_SIZE max_tx_size = get_vartx_max_txsize(mbmi, bsize, 0);
       const int bh = tx_size_high_unit[max_tx_size];
@@ -1845,13 +1828,8 @@
                               w);
         }
       }
-#else
-      write_selected_tx_size(cm, xd, w);
-#endif
     } else {
-#if CONFIG_VAR_TX
       set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, mbmi->skip, xd);
-#endif  // CONFIG_VAR_TX
     }
     int_mv dv_ref = mbmi_ext->ref_mvs[INTRA_FRAME][0];
     av1_encode_dv(w, &mbmi->mv[0].as_mv, &dv_ref.as_mv, &ec_ctx->ndvc);
@@ -1935,10 +1913,10 @@
 #endif  // CONFIG_INTRABC
 
   if (enable_tx_size) write_selected_tx_size(cm, xd, w);
-#if CONFIG_INTRABC && CONFIG_VAR_TX
+#if CONFIG_INTRABC
   if (cm->allow_screen_content_tools)
     set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, mbmi->skip, xd);
-#endif  // CONFIG_INTRABC && CONFIG_VAR_TX
+#endif  // CONFIG_INTRABC
 
   write_intra_mode_kf(cm, ec_ctx, mi, above_mi, left_mi, 0, mbmi->mode, w);
 
@@ -1982,12 +1960,9 @@
 static int rd_token_stats_mismatch(RD_STATS *rd_stats, TOKEN_STATS *token_stats,
                                    int plane) {
   if (rd_stats->txb_coeff_cost[plane] != token_stats->cost) {
-#if CONFIG_VAR_TX
     int r, c;
-#endif
     printf("\nplane %d rd_stats->txb_coeff_cost %d token_stats->cost %d\n",
            plane, rd_stats->txb_coeff_cost[plane], token_stats->cost);
-#if CONFIG_VAR_TX
     printf("rd txb_coeff_cost_map\n");
     for (r = 0; r < TXB_COEFF_COST_MAP_SIZE; ++r) {
       for (c = 0; c < TXB_COEFF_COST_MAP_SIZE; ++c) {
@@ -2003,7 +1978,6 @@
       }
       printf("\n");
     }
-#endif
     return 1;
   }
   return 0;
@@ -2100,26 +2074,24 @@
                  cm->mi_rows, cm->mi_cols);
 
   if (frame_is_intra_only(cm)) {
-#if CONFIG_INTRABC && CONFIG_VAR_TX
+#if CONFIG_INTRABC
     if (cm->allow_screen_content_tools) {
       xd->above_txfm_context =
           cm->above_txfm_context + (mi_col << TX_UNIT_WIDE_LOG2);
       xd->left_txfm_context = xd->left_txfm_context_buffer +
                               ((mi_row & MAX_MIB_MASK) << TX_UNIT_HIGH_LOG2);
     }
-#endif  // CONFIG_INTRABC && CONFIG_VAR_TX
+#endif  // CONFIG_INTRABC
     write_mb_modes_kf(cm, xd,
 #if CONFIG_INTRABC
                       cpi->td.mb.mbmi_ext,
 #endif  // CONFIG_INTRABC
                       mi_row, mi_col, w);
   } else {
-#if CONFIG_VAR_TX
     xd->above_txfm_context =
         cm->above_txfm_context + (mi_col << TX_UNIT_WIDE_LOG2);
     xd->left_txfm_context = xd->left_txfm_context_buffer +
                             ((mi_row & MAX_MIB_MASK) << TX_UNIT_HIGH_LOG2);
-#endif
 #if CONFIG_DUAL_FILTER || CONFIG_WARPED_MOTION
     // has_subpel_mv_component needs the ref frame buffers set up to look
     // up if they are scaled. has_subpel_mv_component is in turn needed by
@@ -2278,7 +2250,6 @@
 #endif  // !CONFIG_LV_MAP
         continue;
       }
-#if CONFIG_VAR_TX
       const struct macroblockd_plane *const pd = &xd->plane[plane];
       BLOCK_SIZE bsize = mbmi->sb_type;
 #if CONFIG_CHROMA_SUB8X8
@@ -2377,34 +2348,6 @@
         }
 #endif  // CONFIG_LV_MAP
       }
-#else
-      const TX_SIZE tx = av1_get_tx_size(plane, xd);
-      TOKEN_STATS token_stats;
-
-      init_token_stats(&token_stats);
-#if CONFIG_LV_MAP
-      (void)tx;
-      av1_write_coeffs_mb(cm, x, w, plane);
-#else  // CONFIG_LV_MAP
-#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK
-      TX_TYPE tx_type = av1_get_tx_type(plane ? PLANE_TYPE_UV : PLANE_TYPE_Y,
-                                        xd, blk_row, blk_col, 0, tx);
-#endif  // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK
-      pack_mb_tokens(w, tok, tok_end, cm->bit_depth, tx,
-#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK
-                     tx_type, is_inter_block(mbmi),
-#endif  // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK
-                     &token_stats);
-#endif  // CONFIG_LV_MAP
-
-#if CONFIG_RD_DEBUG
-      if (is_inter_block(mbmi) && mbmi->sb_type >= BLOCK_8X8 &&
-          rd_token_stats_mismatch(&mbmi->rd_stats, &token_stats, plane)) {
-        dump_mode_info(m);
-        assert(0);
-      }
-#endif  // CONFIG_RD_DEBUG
-#endif  // CONFIG_VAR_TX
 
 #if !CONFIG_LV_MAP
       assert(*tok < tok_end && (*tok)->token == EOSB_TOKEN);
@@ -4635,7 +4578,7 @@
 #endif
   aom_start_encode(header_bc, data);
 
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
   if (cm->tx_mode == TX_MODE_SELECT)
     av1_cond_prob_diff_update(header_bc, &cm->fc->quarter_tx_size_prob,
                               cm->counts.quarter_tx_size, probwt);
@@ -4644,7 +4587,7 @@
   av1_write_txb_probs(cpi, header_bc);
 #endif  // CONFIG_LV_MAP
 
-#if CONFIG_VAR_TX && !CONFIG_NEW_MULTISYMBOL
+#if !CONFIG_NEW_MULTISYMBOL
   if (cm->tx_mode == TX_MODE_SELECT)
     update_txfm_partition_probs(cm, header_bc, counts, probwt);
 #endif
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index b4da70d..12c5ed2 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -115,11 +115,9 @@
 typedef struct {
   TX_TYPE tx_type;
   TX_SIZE tx_size;
-#if CONFIG_VAR_TX
   TX_SIZE min_tx_size;
   TX_SIZE inter_tx_size[MAX_MIB_SIZE][MAX_MIB_SIZE];
   uint8_t blk_skip[MAX_MIB_SIZE * MAX_MIB_SIZE * 8];
-#endif  // CONFIG_VAR_TX
 #if CONFIG_TXK_SEL
   TX_TYPE txk_type[MAX_SB_SQUARE / (TX_SIZE_W_MIN * TX_SIZE_H_MIN)];
 #endif  // CONFIG_TXK_SEL
@@ -161,9 +159,7 @@
   int *m_search_count_ptr;
   int *ex_search_count_ptr;
 
-#if CONFIG_VAR_TX
   unsigned int txb_split_count;
-#endif
 
   // These are set to their default values at the beginning, and then adjusted
   // further in the encoding process.
@@ -196,10 +192,8 @@
   // from extending outside the UMV borders
   MvLimits mv_limits;
 
-#if CONFIG_VAR_TX
   uint8_t blk_skip[MAX_MB_PLANE][MAX_MIB_SIZE * MAX_MIB_SIZE * 8];
   uint8_t blk_skip_drl[MAX_MB_PLANE][MAX_MIB_SIZE * MAX_MIB_SIZE * 8];
-#endif
 
   int skip;
   int skip_chroma_rd;
@@ -277,12 +271,10 @@
   int cfl_cost[CFL_JOINT_SIGNS][CFL_PRED_PLANES][CFL_ALPHABET_SIZE];
 #endif  // CONFIG_CFL
   int tx_size_cost[TX_SIZES - 1][TX_SIZE_CONTEXTS][TX_SIZES];
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
   int quarter_tx_size_cost[2];
 #endif
-#if CONFIG_VAR_TX
   int txfm_partition_cost[TXFM_PARTITION_CONTEXTS][2];
-#endif
 #if CONFIG_EXT_TX
 #if CONFIG_LGT_FROM_PRED
   int intra_lgt_cost[LGT_SIZES][INTRA_MODES][2];
diff --git a/av1/encoder/context_tree.c b/av1/encoder/context_tree.c
index fff15d5..e88b7d6 100644
--- a/av1/encoder/context_tree.c
+++ b/av1/encoder/context_tree.c
@@ -33,9 +33,7 @@
 #endif
 
   for (i = 0; i < MAX_MB_PLANE; ++i) {
-#if CONFIG_VAR_TX
     CHECK_MEM_ERROR(cm, ctx->blk_skip[i], aom_calloc(num_blk, sizeof(uint8_t)));
-#endif
     CHECK_MEM_ERROR(cm, ctx->coeff[i],
                     aom_memalign(32, num_pix * sizeof(*ctx->coeff[i])));
     CHECK_MEM_ERROR(cm, ctx->qcoeff[i],
@@ -65,10 +63,8 @@
 static void free_mode_context(PICK_MODE_CONTEXT *ctx) {
   int i;
   for (i = 0; i < MAX_MB_PLANE; ++i) {
-#if CONFIG_VAR_TX
     aom_free(ctx->blk_skip[i]);
     ctx->blk_skip[i] = 0;
-#endif
     aom_free(ctx->coeff[i]);
     ctx->coeff[i] = 0;
     aom_free(ctx->qcoeff[i]);
diff --git a/av1/encoder/context_tree.h b/av1/encoder/context_tree.h
index 06a92b9..e01504d 100644
--- a/av1/encoder/context_tree.h
+++ b/av1/encoder/context_tree.h
@@ -31,9 +31,7 @@
 #if CONFIG_MRC_TX
   uint8_t *mrc_mask;
 #endif  // CONFIG_MRC_TX
-#if CONFIG_VAR_TX
   uint8_t *blk_skip[MAX_MB_PLANE];
-#endif
 
   tran_low_t *coeff[MAX_MB_PLANE];
   tran_low_t *qcoeff[MAX_MB_PLANE];
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 6f69199..cd36fac 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -238,12 +238,10 @@
   set_mode_info_offsets(cpi, x, xd, mi_row, mi_col);
 
   set_skip_context(xd, mi_row, mi_col);
-#if CONFIG_VAR_TX
   xd->above_txfm_context =
       cm->above_txfm_context + (mi_col << TX_UNIT_WIDE_LOG2);
   xd->left_txfm_context = xd->left_txfm_context_buffer +
                           ((mi_row & MAX_MIB_MASK) << TX_UNIT_HIGH_LOG2);
-#endif
 
   // Set up destination pointers.
   av1_setup_dst_planes(xd->plane, bsize, get_frame_new_buffer(cm), mi_row,
@@ -510,11 +508,9 @@
 
   x->skip = ctx->skip;
 
-#if CONFIG_VAR_TX
   for (i = 0; i < 1; ++i)
     memcpy(x->blk_skip[i], ctx->blk_skip[i],
            sizeof(uint8_t) * ctx->num_4x4_blk);
-#endif
 
   if (dry_run) return;
 
@@ -1360,12 +1356,10 @@
   ENTROPY_CONTEXT l[2 * MAX_MIB_SIZE * MAX_MB_PLANE];
   PARTITION_CONTEXT sa[MAX_MIB_SIZE];
   PARTITION_CONTEXT sl[MAX_MIB_SIZE];
-#if CONFIG_VAR_TX
   TXFM_CONTEXT *p_ta;
   TXFM_CONTEXT *p_tl;
   TXFM_CONTEXT ta[2 * MAX_MIB_SIZE];
   TXFM_CONTEXT tl[2 * MAX_MIB_SIZE];
-#endif
 } RD_SEARCH_MACROBLOCK_CONTEXT;
 
 static void restore_context(MACROBLOCK *x,
@@ -1397,14 +1391,12 @@
          sizeof(*xd->above_seg_context) * mi_width);
   memcpy(xd->left_seg_context + (mi_row & MAX_MIB_MASK), ctx->sl,
          sizeof(xd->left_seg_context[0]) * mi_height);
-#if CONFIG_VAR_TX
   xd->above_txfm_context = ctx->p_ta;
   xd->left_txfm_context = ctx->p_tl;
   memcpy(xd->above_txfm_context, ctx->ta,
          sizeof(*xd->above_txfm_context) * (mi_width << TX_UNIT_WIDE_LOG2));
   memcpy(xd->left_txfm_context, ctx->tl,
          sizeof(*xd->left_txfm_context) * (mi_height << TX_UNIT_HIGH_LOG2));
-#endif
 }
 
 static void save_context(const MACROBLOCK *x, RD_SEARCH_MACROBLOCK_CONTEXT *ctx,
@@ -1437,14 +1429,12 @@
          sizeof(*xd->above_seg_context) * mi_width);
   memcpy(ctx->sl, xd->left_seg_context + (mi_row & MAX_MIB_MASK),
          sizeof(xd->left_seg_context[0]) * mi_height);
-#if CONFIG_VAR_TX
   memcpy(ctx->ta, xd->above_txfm_context,
          sizeof(*xd->above_txfm_context) * (mi_width << TX_UNIT_WIDE_LOG2));
   memcpy(ctx->tl, xd->left_txfm_context,
          sizeof(*xd->left_txfm_context) * (mi_height << TX_UNIT_HIGH_LOG2));
   ctx->p_ta = xd->above_txfm_context;
   ctx->p_tl = xd->left_txfm_context;
-#endif
 }
 
 static void encode_b(const AV1_COMP *const cpi, const TileInfo *const tile,
@@ -1840,12 +1830,10 @@
 
   pc_tree->partitioning = partition;
 
-#if CONFIG_VAR_TX
   xd->above_txfm_context =
       cm->above_txfm_context + (mi_col << TX_UNIT_WIDE_LOG2);
   xd->left_txfm_context = xd->left_txfm_context_buffer +
                           ((mi_row & MAX_MIB_MASK) << TX_UNIT_HIGH_LOG2);
-#endif
   save_context(x, &x_ctx, mi_row, mi_col, bsize);
 
   if (bsize == BLOCK_16X16 && cpi->vaq_refresh) {
@@ -2623,14 +2611,12 @@
   }
 #endif
 
-#if CONFIG_VAR_TX
 #ifndef NDEBUG
   // Nothing should rely on the default value of this array (which is just
   // leftover from encoding the previous block. Setting it to magic number
   // when debugging.
   memset(x->blk_skip[0], 234, sizeof(x->blk_skip[0]));
 #endif  // NDEBUG
-#endif  // CONFIG_VAR_TX
 
   assert(mi_size_wide[bsize] == mi_size_high[bsize]);
 
@@ -2670,12 +2656,10 @@
     partition_vert_allowed &= force_vert_split;
   }
 
-#if CONFIG_VAR_TX
   xd->above_txfm_context =
       cm->above_txfm_context + (mi_col << TX_UNIT_WIDE_LOG2);
   xd->left_txfm_context = xd->left_txfm_context_buffer +
                           ((mi_row & MAX_MIB_MASK) << TX_UNIT_HIGH_LOG2);
-#endif
   save_context(x, &x_ctx, mi_row, mi_col, bsize);
 
 #if CONFIG_FP_MB_STATS
@@ -3485,21 +3469,6 @@
 }
 #endif  // !CONFIG_REF_ADAPT
 
-#if !CONFIG_VAR_TX
-static void reset_skip_tx_size(AV1_COMMON *cm, TX_SIZE max_tx_size) {
-  int mi_row, mi_col;
-  const int mis = cm->mi_stride;
-  MODE_INFO **mi_ptr = cm->mi_grid_visible;
-
-  for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row, mi_ptr += mis) {
-    for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
-      if (txsize_sqr_up_map[mi_ptr[mi_col]->mbmi.tx_size] > max_tx_size)
-        mi_ptr[mi_col]->mbmi.tx_size = max_tx_size;
-    }
-  }
-}
-#endif
-
 static MV_REFERENCE_FRAME get_frame_type(const AV1_COMP *cpi) {
   if (frame_is_intra_only(&cpi->common)) return INTRA_FRAME;
   // We will not update the golden frame with an internal overlay frame
@@ -4049,10 +4018,8 @@
   cm->prev_mi =
       cm->use_prev_frame_mvs ? cm->prev_mip + cm->mi_stride + 1 : NULL;
 
-#if CONFIG_VAR_TX
   x->txb_split_count = 0;
   av1_zero(x->blk_skip_drl);
-#endif
 
 #if CONFIG_MFMV
   av1_setup_motion_field(cm);
@@ -4245,7 +4212,6 @@
     }
     make_consistent_compound_tools(cm);
 
-#if CONFIG_VAR_TX
 #if CONFIG_RECT_TX_EXT
     if (cm->tx_mode == TX_MODE_SELECT && cpi->td.mb.txb_split_count == 0 &&
         counts->quarter_tx_size[1] == 0)
@@ -4253,145 +4219,6 @@
     if (cm->tx_mode == TX_MODE_SELECT && cpi->td.mb.txb_split_count == 0)
 #endif
       cm->tx_mode = ALLOW_32X32 + CONFIG_TX64X64;
-#else
-#if CONFIG_RECT_TX_EXT && CONFIG_EXT_TX
-    if (cm->tx_mode == TX_MODE_SELECT && counts->quarter_tx_size[1] == 0)
-#else
-    if (cm->tx_mode == TX_MODE_SELECT)
-#endif
-    {
-#if CONFIG_TX64X64
-      int count4x4 = 0;
-      int count8x8_8x8p = 0, count8x8_lp = 0;
-      int count16x16_16x16p = 0, count16x16_lp = 0;
-      int count32x32_32x32p = 0, count32x32_lp = 0;
-      int count64x64_64x64p = 0;
-      for (i = 0; i < TX_SIZE_CONTEXTS; ++i) {
-        int depth;
-        // counts->tx_size[max_depth][context_idx][this_depth_level]
-        depth = tx_size_to_depth(TX_4X4);
-        count4x4 += counts->tx_size[TX_8X8 - TX_SIZE_CTX_MIN][i][depth];
-        count4x4 += counts->tx_size[TX_16X16 - TX_SIZE_CTX_MIN][i][depth];
-        count4x4 += counts->tx_size[TX_32X32 - TX_SIZE_CTX_MIN][i][depth];
-        count4x4 += counts->tx_size[TX_64X64 - TX_SIZE_CTX_MIN][i][depth];
-
-        depth = tx_size_to_depth(TX_8X8);
-        count8x8_8x8p += counts->tx_size[TX_8X8 - TX_SIZE_CTX_MIN][i][depth];
-        count8x8_lp += counts->tx_size[TX_16X16 - TX_SIZE_CTX_MIN][i][depth];
-        count8x8_lp += counts->tx_size[TX_32X32 - TX_SIZE_CTX_MIN][i][depth];
-        count8x8_lp += counts->tx_size[TX_64X64 - TX_SIZE_CTX_MIN][i][depth];
-
-        depth = tx_size_to_depth(TX_16X16);
-        count16x16_16x16p +=
-            counts->tx_size[TX_16X16 - TX_SIZE_CTX_MIN][i][depth];
-        count16x16_lp += counts->tx_size[TX_32X32 - TX_SIZE_CTX_MIN][i][depth];
-        count16x16_lp += counts->tx_size[TX_64X64 - TX_SIZE_CTX_MIN][i][depth];
-
-        depth = tx_size_to_depth(TX_32X32);
-        count32x32_32x32p +=
-            counts->tx_size[TX_32X32 - TX_SIZE_CTX_MIN][i][depth];
-        count32x32_lp += counts->tx_size[TX_64X64 - TX_SIZE_CTX_MIN][i][depth];
-
-        depth = tx_size_to_depth(TX_64X64);
-        count64x64_64x64p +=
-            counts->tx_size[TX_64X64 - TX_SIZE_CTX_MIN][i][depth];
-      }
-#if CONFIG_EXT_TX && CONFIG_RECT_TX
-      count4x4 += counts->tx_size_implied[TX_4X4][TX_4X4];
-      count4x4 += counts->tx_size_implied[TX_8X8][TX_4X4];
-      count4x4 += counts->tx_size_implied[TX_16X16][TX_4X4];
-      count4x4 += counts->tx_size_implied[TX_32X32][TX_4X4];
-      count8x8_8x8p += counts->tx_size_implied[TX_8X8][TX_8X8];
-      count8x8_lp += counts->tx_size_implied[TX_16X16][TX_8X8];
-      count8x8_lp += counts->tx_size_implied[TX_32X32][TX_8X8];
-      count8x8_lp += counts->tx_size_implied[TX_64X64][TX_8X8];
-      count16x16_16x16p += counts->tx_size_implied[TX_16X16][TX_16X16];
-      count16x16_lp += counts->tx_size_implied[TX_32X32][TX_16X16];
-      count16x16_lp += counts->tx_size_implied[TX_64X64][TX_16X16];
-      count32x32_32x32p += counts->tx_size_implied[TX_32X32][TX_32X32];
-      count32x32_lp += counts->tx_size_implied[TX_64X64][TX_32X32];
-      count64x64_64x64p += counts->tx_size_implied[TX_64X64][TX_64X64];
-#endif  // CONFIG_EXT_TX && CONFIG_RECT_TX
-      if (count4x4 == 0 && count16x16_lp == 0 && count16x16_16x16p == 0 &&
-          count32x32_lp == 0 && count32x32_32x32p == 0 &&
-          count64x64_64x64p == 0) {
-        cm->tx_mode = ALLOW_8X8;
-        reset_skip_tx_size(cm, TX_8X8);
-      } else if (count8x8_8x8p == 0 && count8x8_lp == 0 &&
-                 count16x16_16x16p == 0 && count16x16_lp == 0 &&
-                 count32x32_32x32p == 0 && count32x32_lp == 0 &&
-                 count64x64_64x64p == 0) {
-        cm->tx_mode = ONLY_4X4;
-        reset_skip_tx_size(cm, TX_4X4);
-      } else if (count4x4 == 0 && count8x8_lp == 0 && count16x16_lp == 0 &&
-                 count32x32_lp == 0) {
-        cm->tx_mode = ALLOW_64X64;
-      } else if (count4x4 == 0 && count8x8_lp == 0 && count16x16_lp == 0 &&
-                 count64x64_64x64p == 0) {
-        cm->tx_mode = ALLOW_32X32;
-        reset_skip_tx_size(cm, TX_32X32);
-      } else if (count4x4 == 0 && count8x8_lp == 0 && count32x32_lp == 0 &&
-                 count32x32_32x32p == 0 && count64x64_64x64p == 0) {
-        cm->tx_mode = ALLOW_16X16;
-        reset_skip_tx_size(cm, TX_16X16);
-      }
-
-#else  // CONFIG_TX64X64
-
-      int count4x4 = 0;
-      int count8x8_lp = 0, count8x8_8x8p = 0;
-      int count16x16_16x16p = 0, count16x16_lp = 0;
-      int count32x32 = 0;
-      for (i = 0; i < TX_SIZE_CONTEXTS; ++i) {
-        int depth;
-        // counts->tx_size[max_depth][context_idx][this_depth_level]
-        depth = tx_size_to_depth(TX_4X4);
-        count4x4 += counts->tx_size[TX_8X8 - TX_SIZE_CTX_MIN][i][depth];
-        count4x4 += counts->tx_size[TX_16X16 - TX_SIZE_CTX_MIN][i][depth];
-        count4x4 += counts->tx_size[TX_32X32 - TX_SIZE_CTX_MIN][i][depth];
-
-        depth = tx_size_to_depth(TX_8X8);
-        count8x8_8x8p += counts->tx_size[TX_8X8 - TX_SIZE_CTX_MIN][i][depth];
-        count8x8_lp += counts->tx_size[TX_16X16 - TX_SIZE_CTX_MIN][i][depth];
-        count8x8_lp += counts->tx_size[TX_32X32 - TX_SIZE_CTX_MIN][i][depth];
-
-        depth = tx_size_to_depth(TX_16X16);
-        count16x16_16x16p +=
-            counts->tx_size[TX_16X16 - TX_SIZE_CTX_MIN][i][depth];
-        count16x16_lp += counts->tx_size[TX_32X32 - TX_SIZE_CTX_MIN][i][depth];
-
-        depth = tx_size_to_depth(TX_32X32);
-        count32x32 += counts->tx_size[TX_32X32 - TX_SIZE_CTX_MIN][i][depth];
-      }
-#if CONFIG_EXT_TX && CONFIG_RECT_TX
-      count4x4 += counts->tx_size_implied[TX_4X4][TX_4X4];
-      count4x4 += counts->tx_size_implied[TX_8X8][TX_4X4];
-      count4x4 += counts->tx_size_implied[TX_16X16][TX_4X4];
-      count4x4 += counts->tx_size_implied[TX_32X32][TX_4X4];
-      count8x8_8x8p += counts->tx_size_implied[TX_8X8][TX_8X8];
-      count8x8_lp += counts->tx_size_implied[TX_16X16][TX_8X8];
-      count8x8_lp += counts->tx_size_implied[TX_32X32][TX_8X8];
-      count16x16_16x16p += counts->tx_size_implied[TX_16X16][TX_16X16];
-      count16x16_lp += counts->tx_size_implied[TX_32X32][TX_16X16];
-      count32x32 += counts->tx_size_implied[TX_32X32][TX_32X32];
-#endif  // CONFIG_EXT_TX && CONFIG_RECT_TX
-      if (count4x4 == 0 && count16x16_lp == 0 && count16x16_16x16p == 0 &&
-          count32x32 == 0) {
-        cm->tx_mode = ALLOW_8X8;
-        reset_skip_tx_size(cm, TX_8X8);
-      } else if (count8x8_8x8p == 0 && count16x16_16x16p == 0 &&
-                 count8x8_lp == 0 && count16x16_lp == 0 && count32x32 == 0) {
-        cm->tx_mode = ONLY_4X4;
-        reset_skip_tx_size(cm, TX_4X4);
-      } else if (count8x8_lp == 0 && count16x16_lp == 0 && count4x4 == 0) {
-        cm->tx_mode = ALLOW_32X32;
-      } else if (count32x32 == 0 && count8x8_lp == 0 && count4x4 == 0) {
-        cm->tx_mode = ALLOW_16X16;
-        reset_skip_tx_size(cm, TX_16X16);
-      }
-#endif  // CONFIG_TX64X64
-    }
-#endif
   } else {
     make_consistent_compound_tools(cm);
     encode_frame_internal(cpi);
@@ -4496,7 +4323,6 @@
 }
 #endif
 
-#if CONFIG_VAR_TX
 static void update_txfm_count(MACROBLOCK *x, MACROBLOCKD *xd,
                               FRAME_COUNTS *counts, TX_SIZE tx_size, int depth,
                               int blk_row, int blk_col) {
@@ -4649,7 +4475,6 @@
     for (idx = 0; idx < mi_width; idx += bw)
       set_txfm_context(xd, max_tx_size, idy, idx);
 }
-#endif
 
 void av1_update_tx_type_count(const AV1_COMMON *cm, MACROBLOCKD *xd,
 #if CONFIG_TXK_SEL
@@ -4827,9 +4652,7 @@
       }
     }
 
-#if CONFIG_VAR_TX
     mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
-#endif
 #if CONFIG_LV_MAP
     av1_update_txb_context(cpi, td, dry_run, block_size, rate, mi_row, mi_col);
 #else   // CONFIG_LV_MAP
@@ -4890,17 +4713,9 @@
 #endif
 
     av1_encode_sb((AV1_COMMON *)cm, x, block_size, mi_row, mi_col);
-#if CONFIG_VAR_TX
     if (mbmi->skip) mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
     av1_tokenize_sb_vartx(cpi, td, t, dry_run, mi_row, mi_col, block_size,
                           rate);
-#else
-#if CONFIG_LV_MAP
-    av1_update_txb_context(cpi, td, dry_run, block_size, rate, mi_row, mi_col);
-#else   // CONFIG_LV_MAP
-    av1_tokenize_sb(cpi, td, t, dry_run, block_size, rate, mi_row, mi_col);
-#endif  // CONFIG_LV_MAP
-#endif
   }
 
 #if CONFIG_DIST_8X8
@@ -4912,20 +4727,15 @@
 #endif  // CONFIG_DIST_8X8
 
   if (!dry_run) {
-#if CONFIG_VAR_TX
     TX_SIZE tx_size =
         is_inter && !mbmi->skip ? mbmi->min_tx_size : mbmi->tx_size;
-#else
-    TX_SIZE tx_size = mbmi->tx_size;
-#endif
     if (cm->tx_mode == TX_MODE_SELECT && !xd->lossless[mbmi->segment_id] &&
-#if (CONFIG_VAR_TX || CONFIG_EXT_TX) && CONFIG_RECT_TX
+#if CONFIG_RECT_TX
         mbmi->sb_type > BLOCK_4X4 &&
 #else
         mbmi->sb_type >= BLOCK_8X8 &&
-#endif  // (CONFIG_VAR_TX || CONFIG_EXT_TX) && CONFIG_RECT_TX
+#endif  // CONFIG_RECT_TX
         !(is_inter && (mbmi->skip || seg_skip))) {
-#if CONFIG_VAR_TX
       if (is_inter) {
         tx_partition_count_update(cm, x, bsize, mi_row, mi_col, td->counts);
       } else {
@@ -4937,17 +4747,8 @@
         ++td->counts->tx_size[tx_size_cat][tx_size_ctx][depth];
         if (tx_size != max_txsize_rect_lookup[bsize]) ++x->txb_split_count;
       }
-#else
-      const int tx_size_ctx = get_tx_size_context(xd);
-      const int32_t tx_size_cat = is_inter ? inter_tx_size_cat_lookup[bsize]
-                                           : intra_tx_size_cat_lookup[bsize];
-      const TX_SIZE coded_tx_size = txsize_sqr_up_map[tx_size];
-      const int depth = tx_size_to_depth(coded_tx_size);
 
-      ++td->counts->tx_size[tx_size_cat][tx_size_ctx][depth];
-#endif
-
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
       if (is_quarter_tx_allowed(xd, mbmi, is_inter) &&
           quarter_txsize_lookup[bsize] != max_txsize_rect_lookup[bsize] &&
           (mbmi->tx_size == quarter_txsize_lookup[bsize] ||
@@ -4989,10 +4790,8 @@
           if (mi_col + i < cm->mi_cols && mi_row + j < cm->mi_rows)
             mi_8x8[mis * j + i]->mbmi.tx_size = intra_tx_size;
 
-#if CONFIG_VAR_TX
       mbmi->min_tx_size = get_min_tx_size(intra_tx_size);
       if (intra_tx_size != max_txsize_rect_lookup[bsize]) ++x->txb_split_count;
-#endif
     }
 
 #if !CONFIG_TXK_SEL
@@ -5000,7 +4799,6 @@
 #endif
   }
 
-#if CONFIG_VAR_TX
   if (cm->tx_mode == TX_MODE_SELECT && mbmi->sb_type > BLOCK_4X4 && is_inter &&
       !(mbmi->skip || seg_skip) && !xd->lossless[mbmi->segment_id]) {
     if (dry_run) tx_partition_set_contexts(cm, xd, bsize, mi_row, mi_col);
@@ -5019,7 +4817,6 @@
     mbmi->tx_size = tx_size;
     set_txfm_ctxs(tx_size, xd->n8_w, xd->n8_h, (mbmi->skip || seg_skip), xd);
   }
-#endif  // CONFIG_VAR_TX
 #if CONFIG_CFL && CONFIG_CHROMA_SUB8X8
   CFL_CTX *const cfl = xd->cfl;
 #if CONFIG_DEBUG
diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c
index 2fd99b7..c930587 100644
--- a/av1/encoder/encodemb.c
+++ b/av1/encoder/encodemb.c
@@ -399,11 +399,7 @@
   (void)blk_row;
   (void)blk_col;
   (void)fast_mode;
-#if CONFIG_VAR_TX
   int ctx = get_entropy_context(tx_size, a, l);
-#else
-  int ctx = combine_entropy_contexts(*a, *l);
-#endif  // CONFIG_VAR_TX
   return optimize_b_greedy(cm, mb, plane, blk_row, blk_col, block, tx_size,
                            ctx);
 #else   // !CONFIG_LV_MAP
@@ -600,35 +596,23 @@
   uint8_t *dst;
   ENTROPY_CONTEXT *a, *l;
 
-#if CONFIG_VAR_TX
   int bw = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
-#endif
   dst = &pd->dst
              .buf[(blk_row * pd->dst.stride + blk_col) << tx_size_wide_log2[0]];
 
   a = &args->ta[blk_col];
   l = &args->tl[blk_row];
-#if CONFIG_VAR_TX
   ctx = get_entropy_context(tx_size, a, l);
-#else
-  ctx = combine_entropy_contexts(*a, *l);
-#endif
 
-#if CONFIG_VAR_TX
   // Assert not magic number (uninitialized).
   assert(x->blk_skip[plane][blk_row * bw + blk_col] != 234);
 
-  if (x->blk_skip[plane][blk_row * bw + blk_col] == 0)
-#endif
-  {
+  if (x->blk_skip[plane][blk_row * bw + blk_col] == 0) {
     av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, tx_size,
                     ctx, AV1_XFORM_QUANT_FP);
-  }
-#if CONFIG_VAR_TX
-  else {
+  } else {
     p->eobs[block] = 0;
   }
-#endif
 
   av1_optimize_b(cm, x, plane, blk_row, blk_col, block, plane_bsize, tx_size, a,
                  l, 0);
@@ -657,7 +641,6 @@
   }
 }
 
-#if CONFIG_VAR_TX
 static void encode_block_inter(int plane, int block, int blk_row, int blk_col,
                                BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
                                void *arg) {
@@ -720,7 +703,6 @@
     }
   }
 }
-#endif
 
 typedef struct encode_block_pass1_args {
   AV1_COMMON *cm;
@@ -794,7 +776,6 @@
 
     bsize = scale_chroma_bsize(bsize, subsampling_x, subsampling_y);
 
-#if CONFIG_VAR_TX
     // TODO(jingning): Clean this up.
     const struct macroblockd_plane *const pd = &xd->plane[plane];
     const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
@@ -809,18 +790,12 @@
     int block = 0;
     int step = tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
     av1_get_entropy_contexts(bsize, 0, pd, ctx.ta[plane], ctx.tl[plane]);
-#else
-    const struct macroblockd_plane *const pd = &xd->plane[plane];
-    const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
-    av1_get_entropy_contexts(bsize, tx_size, pd, ctx.ta[plane], ctx.tl[plane]);
-#endif
 
     av1_subtract_plane(x, bsize, plane);
 
     arg.ta = ctx.ta[plane];
     arg.tl = ctx.tl[plane];
 
-#if CONFIG_VAR_TX
     const BLOCK_SIZE max_unit_bsize = get_plane_block_size(BLOCK_64X64, pd);
     int mu_blocks_wide =
         block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0];
@@ -844,10 +819,6 @@
         }
       }
     }
-#else
-    av1_foreach_transformed_block_in_plane(xd, bsize, plane, encode_block,
-                                           &arg);
-#endif
   }
 }
 
@@ -862,12 +833,10 @@
   *a = *l = p->txb_entropy_ctx[block];
 #endif  // !CONFIG_LV_MAP
 
-#if CONFIG_VAR_TX || CONFIG_LV_MAP
   int i;
   for (i = 0; i < tx_size_wide_unit[tx_size]; ++i) a[i] = a[0];
 
   for (i = 0; i < tx_size_high_unit[tx_size]; ++i) l[i] = l[0];
-#endif
 }
 
 static void encode_block_intra_and_set_context(int plane, int block,
diff --git a/av1/encoder/ethread.c b/av1/encoder/ethread.c
index 1ea99d6..cb33ec1 100644
--- a/av1/encoder/ethread.c
+++ b/av1/encoder/ethread.c
@@ -189,9 +189,7 @@
     if (i < cpi->num_workers - 1) {
       av1_accumulate_frame_counts(&cm->counts, thread_data->td->counts);
       accumulate_rd_opt(&cpi->td, thread_data->td);
-#if CONFIG_VAR_TX
       cpi->td.mb.txb_split_count += thread_data->td->mb.txb_split_count;
-#endif
     }
   }
 }
diff --git a/av1/encoder/hybrid_fwd_txfm.c b/av1/encoder/hybrid_fwd_txfm.c
index 486c604..d60993a 100644
--- a/av1/encoder/hybrid_fwd_txfm.c
+++ b/av1/encoder/hybrid_fwd_txfm.c
@@ -148,7 +148,7 @@
 }
 #endif  // CONFIG_TX64X64
 
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
 static void fwd_txfm_16x4(const int16_t *src_diff, tran_low_t *coeff,
                           int diff_stride, TxfmParam *txfm_param) {
 #if CONFIG_LGT
@@ -551,7 +551,7 @@
       fwd_txfm_32x16(src_diff, coeff, diff_stride, txfm_param);
       break;
     case TX_4X4: fwd_txfm_4x4(src_diff, coeff, diff_stride, txfm_param); break;
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
     case TX_4X16:
       fwd_txfm_4x16(src_diff, coeff, diff_stride, txfm_param);
       break;
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index a5fed79..8c69a44 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -231,7 +231,7 @@
       av1_cost_tokens_from_cdf(x->tx_size_cost[i][j], fc->tx_size_cdf[i][j],
                                NULL);
 
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
 #if CONFIG_NEW_MULTISYMBOL
   av1_cost_tokens_from_cdf(x->quarter_tx_size_cost, fc->quarter_tx_size_cdf,
                            NULL);
@@ -241,7 +241,6 @@
 #endif
 #endif
 
-#if CONFIG_VAR_TX
   for (i = 0; i < TXFM_PARTITION_CONTEXTS; ++i) {
 #if CONFIG_NEW_MULTISYMBOL
     av1_cost_tokens_from_cdf(x->txfm_partition_cost[i],
@@ -251,7 +250,6 @@
     x->txfm_partition_cost[i][1] = av1_cost_bit(fc->txfm_partition_prob[i], 1);
 #endif
   }
-#endif
 
 #if CONFIG_EXT_TX
 #if CONFIG_LGT_FROM_PRED
@@ -998,7 +996,7 @@
       for (i = 0; i < num_4x4_h; i += 4)
         t_left[i] = !!*(const uint32_t *)&left[i];
       break;
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
     case TX_4X16:
       memcpy(t_above, above, sizeof(ENTROPY_CONTEXT) * num_4x4_w);
       for (i = 0; i < num_4x4_h; i += 4)
diff --git a/av1/encoder/rd.h b/av1/encoder/rd.h
index 3bbbb64..8f64fcb 100644
--- a/av1/encoder/rd.h
+++ b/av1/encoder/rd.h
@@ -383,14 +383,12 @@
 #if CONFIG_RD_DEBUG
   for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
     rd_stats->txb_coeff_cost[plane] = 0;
-#if CONFIG_VAR_TX
     {
       int r, c;
       for (r = 0; r < TXB_COEFF_COST_MAP_SIZE; ++r)
         for (c = 0; c < TXB_COEFF_COST_MAP_SIZE; ++c)
           rd_stats->txb_coeff_cost_map[plane][r][c] = 0;
     }
-#endif
   }
 #endif
 }
@@ -410,14 +408,12 @@
 #if CONFIG_RD_DEBUG
   for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
     rd_stats->txb_coeff_cost[plane] = INT_MAX;
-#if CONFIG_VAR_TX
     {
       int r, c;
       for (r = 0; r < TXB_COEFF_COST_MAP_SIZE; ++r)
         for (c = 0; c < TXB_COEFF_COST_MAP_SIZE; ++c)
           rd_stats->txb_coeff_cost_map[plane][r][c] = INT_MAX;
     }
-#endif
   }
 #endif
 }
@@ -435,7 +431,6 @@
 #if CONFIG_RD_DEBUG
   for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
     rd_stats_dst->txb_coeff_cost[plane] += rd_stats_src->txb_coeff_cost[plane];
-#if CONFIG_VAR_TX
     {
       // TODO(angiebird): optimize this part
       int r, c;
@@ -448,7 +443,6 @@
         }
       assert(ref_txb_coeff_cost == rd_stats_dst->txb_coeff_cost[plane]);
     }
-#endif
   }
 #endif
 }
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 6760e26..8a9e2da 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -487,7 +487,7 @@
   unsigned sse;
 
   if (txb_rows == visible_rows && txb_cols == visible_cols
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
       && tx_bsize < BLOCK_SIZES
 #endif
       ) {
@@ -1622,10 +1622,6 @@
   const int cat6_bits = av1_get_cat6_extrabits_size(tx_size, 8);
 #endif  // CONFIG_HIGHBITDEPTH
 
-#if !CONFIG_VAR_TX
-  // Check for consistency of tx_size with mode info
-  assert(tx_size == av1_get_tx_size(plane, xd));
-#endif  // !CONFIG_VAR_TX
   (void)cm;
 
   if (eob == 0) {
@@ -1757,7 +1753,7 @@
                                BLOCK_SIZE plane_bsize, int blk_row, int blk_col,
                                BLOCK_SIZE tx_bsize, int *width, int *height,
                                int *visible_width, int *visible_height) {
-#if !(CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX))
+#if !(CONFIG_RECT_TX_EXT)
   assert(tx_bsize <= plane_bsize);
 #endif
   int txb_height = block_size_high[tx_bsize];
@@ -2057,10 +2053,6 @@
       x->tune_metric != AOM_TUNE_PSNR;
 #endif  // CONFIG_DIST_8X8
 
-#if !CONFIG_VAR_TX
-  assert(tx_size == av1_get_tx_size(plane, xd));
-#endif  // !CONFIG_VAR_TX
-
   av1_init_rd_stats(&this_rd_stats);
 
   if (args->exit_early) return;
@@ -2321,7 +2313,7 @@
     const int depth = tx_size_to_depth(coded_tx_size);
     const int tx_size_ctx = get_tx_size_context(xd);
     int r_tx_size = x->tx_size_cost[tx_size_cat][tx_size_ctx][depth];
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
     if (is_quarter_tx_allowed(xd, mbmi, is_inter) && tx_size != coded_tx_size)
       r_tx_size +=
           x->quarter_tx_size_cost[tx_size == quarter_txsize_lookup[bsize]];
@@ -2364,9 +2356,7 @@
 #if CONFIG_LGT_FROM_PRED
   assert(!xd->mi[0]->mbmi.use_lgt);
 #endif
-#if CONFIG_VAR_TX
   tx_size = get_min_tx_size(tx_size);
-#endif
 
   const MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
   const int is_inter = is_inter_block(mbmi);
@@ -2553,9 +2543,7 @@
   av1_invalid_rd_stats(rd_stats);
 
   mbmi->tx_size = tx_size_from_tx_mode(bs, cm->tx_mode, is_inter);
-#if CONFIG_VAR_TX
   mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
-#endif  // CONFIG_VAR_TX
 #if CONFIG_EXT_TX
   const TxSetType tx_set_type =
       get_ext_tx_set_type(mbmi->tx_size, bs, is_inter, cm->reduced_tx_set_used);
@@ -2706,20 +2694,16 @@
 
   mbmi->tx_size = TX_4X4;
   mbmi->tx_type = DCT_DCT;
-#if CONFIG_VAR_TX
   mbmi->min_tx_size = get_min_tx_size(TX_4X4);
-#endif  // CONFIG_VAR_TX
 
   txfm_rd_in_plane(x, cpi, rd_stats, ref_best_rd, 0, bs, mbmi->tx_size,
                    cpi->sf.use_fast_coef_costing);
 }
 
-#if CONFIG_TXK_SEL || CONFIG_VAR_TX
 static INLINE int bsize_to_num_blk(BLOCK_SIZE bsize) {
   int num_blk = 1 << (num_pels_log2_lookup[bsize] - 2 * tx_size_wide_log2[0]);
   return num_blk;
 }
-#endif  // CONFIG_TXK_SEL || CONFIG_VAR_TX
 
 static void choose_tx_size_type_from_rd(const AV1_COMP *const cpi,
                                         MACROBLOCK *x, RD_STATS *rd_stats,
@@ -2970,9 +2954,7 @@
   memcpy(mbmi->txk_type, best_txk_type, sizeof(best_txk_type[0]) * 256);
 #endif
 
-#if CONFIG_VAR_TX
   mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size);
-#endif  // CONFIG_VAR_TX
 
 #if !CONFIG_EXT_TX
   if (mbmi->tx_size >= TX_32X32) assert(mbmi->tx_type == DCT_DCT);
@@ -3870,7 +3852,6 @@
   return is_cost_valid;
 }
 
-#if CONFIG_VAR_TX
 void av1_tx_block_rd_b(const AV1_COMP *cpi, MACROBLOCK *x, TX_SIZE tx_size,
                        int blk_row, int blk_col, int plane, int block,
                        int plane_bsize, const ENTROPY_CONTEXT *a,
@@ -4666,14 +4647,12 @@
   tx_rd_info->hash_value = hash;
   tx_rd_info->tx_type = mbmi->tx_type;
   tx_rd_info->tx_size = mbmi->tx_size;
-#if CONFIG_VAR_TX
   tx_rd_info->min_tx_size = mbmi->min_tx_size;
   memcpy(tx_rd_info->blk_skip, x->blk_skip[0],
          sizeof(tx_rd_info->blk_skip[0]) * n4);
   for (int idy = 0; idy < xd->n8_h; ++idy)
     for (int idx = 0; idx < xd->n8_w; ++idx)
       tx_rd_info->inter_tx_size[idy][idx] = mbmi->inter_tx_size[idy][idx];
-#endif  // CONFIG_VAR_TX
 #if CONFIG_TXK_SEL
   av1_copy(tx_rd_info->txk_type, mbmi->txk_type);
 #endif  // CONFIG_TXK_SEL
@@ -4686,14 +4665,12 @@
   MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
   mbmi->tx_type = tx_rd_info->tx_type;
   mbmi->tx_size = tx_rd_info->tx_size;
-#if CONFIG_VAR_TX
   mbmi->min_tx_size = tx_rd_info->min_tx_size;
   memcpy(x->blk_skip[0], tx_rd_info->blk_skip,
          sizeof(tx_rd_info->blk_skip[0]) * n4);
   for (int idy = 0; idy < xd->n8_h; ++idy)
     for (int idx = 0; idx < xd->n8_w; ++idx)
       mbmi->inter_tx_size[idy][idx] = tx_rd_info->inter_tx_size[idy][idx];
-#endif  // CONFIG_VAR_TX
 #if CONFIG_TXK_SEL
   av1_copy(mbmi->txk_type, tx_rd_info->txk_type);
 #endif  // CONFIG_TXK_SEL
@@ -4712,7 +4689,7 @@
   DECLARE_ALIGNED(32, tran_low_t, DCT_coefs[32 * 32]);
   TxfmParam param;
   param.tx_type = DCT_DCT;
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
   param.tx_size = max_txsize_rect_lookup[bsize];
 #else
   param.tx_size = max_txsize_lookup[bsize];
@@ -4744,7 +4721,7 @@
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
   const int n4 = bsize_to_num_blk(bsize);
-#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX
   const TX_SIZE tx_size = max_txsize_rect_lookup[bsize];
 #else
   const TX_SIZE tx_size = max_txsize_lookup[bsize];
@@ -5116,7 +5093,6 @@
 
   return is_cost_valid;
 }
-#endif  // CONFIG_VAR_TX
 
 static void rd_pick_palette_intra_sbuv(const AV1_COMP *const cpi, MACROBLOCK *x,
                                        int dc_mode_cost,
@@ -8045,9 +8021,7 @@
   int rate2_nocoeff = 0, best_xskip, best_disable_skip = 0;
   RD_STATS best_rd_stats, best_rd_stats_y, best_rd_stats_uv;
   MB_MODE_INFO base_mbmi, best_mbmi;
-#if CONFIG_VAR_TX
   uint8_t best_blk_skip[MAX_MB_PLANE][MAX_MIB_SIZE * MAX_MIB_SIZE * 4];
-#endif  // CONFIG_VAR_TX
 #endif  // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
 
 #if CONFIG_WARPED_MOTION
@@ -8256,7 +8230,6 @@
 
       // cost and distortion
       av1_subtract_plane(x, bsize, 0);
-#if CONFIG_VAR_TX
       if (cm->tx_mode == TX_MODE_SELECT && !xd->lossless[mbmi->segment_id]) {
         select_tx_type_yrd(cpi, x, rd_stats_y, bsize, mi_row, mi_col,
                            ref_best_rd);
@@ -8269,11 +8242,6 @@
         memset(x->blk_skip[0], rd_stats_y->skip,
                sizeof(uint8_t) * xd->n8_h * xd->n8_w * 4);
       }
-#else
-    /* clang-format off */
-      super_block_yrd(cpi, x, rd_stats_y, bsize, ref_best_rd);
-/* clang-format on */
-#endif  // CONFIG_VAR_TX
 
       if (rd_stats_y->rate == INT_MAX) {
         av1_invalid_rd_stats(rd_stats);
@@ -8293,14 +8261,9 @@
 
       rdcosty = RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist);
       rdcosty = AOMMIN(rdcosty, RDCOST(x->rdmult, 0, rd_stats->sse));
-/* clang-format off */
-#if CONFIG_VAR_TX
+      /* clang-format off */
       is_cost_valid_uv =
           inter_block_uvrd(cpi, x, rd_stats_uv, bsize, ref_best_rd - rdcosty);
-#else
-      is_cost_valid_uv =
-          super_block_uvrd(cpi, x, rd_stats_uv, bsize, ref_best_rd - rdcosty);
-#endif  // CONFIG_VAR_TX
       if (!is_cost_valid_uv) {
 #if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
         continue;
@@ -8383,11 +8346,9 @@
       best_rd_stats = *rd_stats;
       best_rd_stats_y = *rd_stats_y;
       best_rd_stats_uv = *rd_stats_uv;
-#if CONFIG_VAR_TX
       for (int i = 0; i < MAX_MB_PLANE; ++i)
         memcpy(best_blk_skip[i], x->blk_skip[i],
                sizeof(uint8_t) * xd->n8_h * xd->n8_w * 4);
-#endif  // CONFIG_VAR_TX
       best_xskip = x->skip;
       best_disable_skip = *disable_skip;
     }
@@ -8402,11 +8363,9 @@
   *rd_stats = best_rd_stats;
   *rd_stats_y = best_rd_stats_y;
   *rd_stats_uv = best_rd_stats_uv;
-#if CONFIG_VAR_TX
   for (int i = 0; i < MAX_MB_PLANE; ++i)
     memcpy(x->blk_skip[i], best_blk_skip[i],
            sizeof(uint8_t) * xd->n8_h * xd->n8_w * 4);
-#endif  // CONFIG_VAR_TX
   x->skip = best_xskip;
   *disable_skip = best_disable_skip;
 #endif  // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
@@ -9214,7 +9173,6 @@
     const int rate_mode = x->intrabc_cost[1];
     RD_STATS rd_stats, rd_stats_uv;
     av1_subtract_plane(x, bsize, 0);
-#if CONFIG_VAR_TX
     if (cm->tx_mode == TX_MODE_SELECT && !xd->lossless[mbmi->segment_id]) {
       select_tx_type_yrd(cpi, x, &rd_stats, bsize, mi_row, mi_col, INT64_MAX);
     } else {
@@ -9226,9 +9184,6 @@
       memset(x->blk_skip[0], rd_stats.skip,
              sizeof(uint8_t) * xd->n8_h * xd->n8_w * 4);
     }
-#else
-    super_block_yrd(cpi, x, &rd_stats, bsize, INT64_MAX);
-#endif  // CONFIG_VAR_TX
     super_block_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
     av1_merge_rd_stats(&rd_stats, &rd_stats_uv);
 #if CONFIG_RD_DEBUG
@@ -10527,11 +10482,9 @@
                            rate_y - rate_uv,
                        total_sse);
         }
-#if CONFIG_VAR_TX
         for (i = 0; i < MAX_MB_PLANE; ++i)
           memcpy(x->blk_skip_drl[i], x->blk_skip[i],
                  sizeof(uint8_t) * ctx->num_4x4_blk);
-#endif  // CONFIG_VAR_TX
 
         for (ref_idx = 0; ref_idx < ref_set; ++ref_idx) {
           int64_t tmp_alt_rd = INT64_MAX;
@@ -10705,11 +10658,9 @@
             tmp_ref_rd = tmp_alt_rd;
             backup_mbmi = *mbmi;
             backup_skip = x->skip;
-#if CONFIG_VAR_TX
             for (i = 0; i < MAX_MB_PLANE; ++i)
               memcpy(x->blk_skip_drl[i], x->blk_skip[i],
                      sizeof(uint8_t) * ctx->num_4x4_blk);
-#endif  // CONFIG_VAR_TX
           } else {
             *mbmi = backup_mbmi;
             x->skip = backup_skip;
@@ -10719,11 +10670,9 @@
         frame_mv[NEARMV][ref_frame] = backup_mv;
         frame_mv[NEWMV][ref_frame] = backup_fmv[0];
         if (comp_pred) frame_mv[NEWMV][second_ref_frame] = backup_fmv[1];
-#if CONFIG_VAR_TX
         for (i = 0; i < MAX_MB_PLANE; ++i)
           memcpy(x->blk_skip[i], x->blk_skip_drl[i],
                  sizeof(uint8_t) * ctx->num_4x4_blk);
-#endif  // CONFIG_VAR_TX
       }
       mbmi_ext->ref_mvs[ref_frame][0] = backup_ref_mv[0];
       if (comp_pred) mbmi_ext->ref_mvs[second_ref_frame][0] = backup_ref_mv[1];
@@ -10848,11 +10797,9 @@
             rate_y +
             x->skip_cost[av1_get_skip_context(xd)][this_skip2 || skippable];
         best_rate_uv = rate_uv;
-#if CONFIG_VAR_TX
         for (i = 0; i < MAX_MB_PLANE; ++i)
           memcpy(ctx->blk_skip[i], x->blk_skip[i],
                  sizeof(uint8_t) * ctx->num_4x4_blk);
-#endif  // CONFIG_VAR_TX
       }
     }
 
@@ -10926,7 +10873,6 @@
       }
 #endif  // CONFIG_MOTION_VAR
       av1_subtract_plane(x, bsize, 0);
-#if CONFIG_VAR_TX
       if (cm->tx_mode == TX_MODE_SELECT || xd->lossless[mbmi->segment_id]) {
         select_tx_type_yrd(cpi, x, &rd_stats_y, bsize, mi_row, mi_col,
                            INT64_MAX);
@@ -10942,10 +10888,6 @@
       }
 
       inter_block_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
-#else
-      super_block_yrd(cpi, x, &rd_stats_y, bsize, INT64_MAX);
-      super_block_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
-#endif  // CONFIG_VAR_TX
     } else {
       super_block_yrd(cpi, x, &rd_stats_y, bsize, INT64_MAX);
       super_block_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
@@ -10967,15 +10909,12 @@
     if (RDCOST(x->rdmult, best_rate_y + best_rate_uv, rd_cost->dist) >
         RDCOST(x->rdmult, rd_stats_y.rate + rd_stats_uv.rate,
                (rd_stats_y.dist + rd_stats_uv.dist))) {
-#if CONFIG_VAR_TX
       int idx, idy;
-#endif  // CONFIG_VAR_TX
       best_mbmode.tx_type = mbmi->tx_type;
       best_mbmode.tx_size = mbmi->tx_size;
 #if CONFIG_LGT_FROM_PRED
       best_mbmode.use_lgt = mbmi->use_lgt;
 #endif
-#if CONFIG_VAR_TX
       for (idy = 0; idy < xd->n8_h; ++idy)
         for (idx = 0; idx < xd->n8_w; ++idx)
           best_mbmode.inter_tx_size[idy][idx] = mbmi->inter_tx_size[idy][idx];
@@ -10985,7 +10924,6 @@
                sizeof(uint8_t) * ctx->num_4x4_blk);
 
       best_mbmode.min_tx_size = mbmi->min_tx_size;
-#endif  // CONFIG_VAR_TX
       rd_cost->rate +=
           (rd_stats_y.rate + rd_stats_uv.rate - best_rate_y - best_rate_uv);
       rd_cost->dist = rd_stats_y.dist + rd_stats_uv.dist;
@@ -11731,7 +11669,6 @@
   av1_build_inter_predictors_sb(cm, xd, mi_row, mi_col, NULL, bsize);
 
   av1_subtract_plane(x, bsize, 0);
-#if CONFIG_VAR_TX
   if (cm->tx_mode == TX_MODE_SELECT && !xd->lossless[mbmi->segment_id]) {
     select_tx_type_yrd(cpi, x, &rd_stats_y, bsize, mi_row, mi_col, INT64_MAX);
   } else {
@@ -11744,10 +11681,6 @@
            sizeof(uint8_t) * xd->n8_h * xd->n8_w * 4);
   }
   inter_block_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
-#else
-  super_block_yrd(cpi, x, &rd_stats_y, bsize, INT64_MAX);
-  super_block_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
-#endif
   assert(rd_stats_y.rate != INT_MAX && rd_stats_uv.rate != INT_MAX);
   if (rd_stats_y.skip && rd_stats_uv.skip) {
     rd_stats_y.rate = rate_skip1;
@@ -11781,7 +11714,6 @@
   av1_build_ncobmc_inter_predictors_sb(cm, xd, mi_row, mi_col);
 
   av1_subtract_plane(x, bsize, 0);
-#if CONFIG_VAR_TX
   if (cm->tx_mode == TX_MODE_SELECT && !xd->lossless[mbmi->segment_id]) {
     select_tx_type_yrd(cpi, x, &rd_stats_y, bsize, mi_row, mi_col, INT64_MAX);
   } else {
@@ -11794,10 +11726,6 @@
            sizeof(uint8_t) * xd->n8_h * xd->n8_w * 4);
   }
   inter_block_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
-#else
-  super_block_yrd(cpi, x, &rd_stats_y, bsize, INT64_MAX);
-  super_block_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
-#endif
   assert(rd_stats_y.rate != INT_MAX && rd_stats_uv.rate != INT_MAX);
   if (rd_stats_y.skip && rd_stats_uv.skip) {
     rd_stats_y.rate = rate_skip1;
@@ -11893,7 +11821,6 @@
 #endif
   av1_subtract_plane(x, bsize, 0);
 
-#if CONFIG_VAR_TX
   if (cm->tx_mode == TX_MODE_SELECT && !xd->lossless[mbmi->segment_id]) {
     select_tx_type_yrd(cpi, x, &rd_stats_y, bsize, mi_row, mi_col, INT64_MAX);
   } else {
@@ -11906,10 +11833,6 @@
            sizeof(uint8_t) * xd->n8_h * xd->n8_w * 4);
   }
   inter_block_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
-#else
-  super_block_yrd(cpi, x, &rd_stats_y, bsize, INT64_MAX);
-  super_block_uvrd(cpi, x, &rd_stats_uv, bsize, INT64_MAX);
-#endif
   assert(rd_stats_y.rate != INT_MAX && rd_stats_uv.rate != INT_MAX);
 
   if (rd_stats_y.skip && rd_stats_uv.skip) {
@@ -11963,12 +11886,10 @@
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
   BLOCK_SIZE bsize = mbmi->sb_type;
-#if CONFIG_VAR_TX
   const int n4 = bsize_to_num_blk(bsize);
   uint8_t st_blk_skip[MAX_MIB_SIZE * MAX_MIB_SIZE * 8];
   uint8_t obmc_blk_skip[MAX_MIB_SIZE * MAX_MIB_SIZE * 8];
   uint8_t ncobmc_blk_skip[MAX_MIB_SIZE * MAX_MIB_SIZE * 8];
-#endif
   MB_MODE_INFO st_mbmi, obmc_mbmi, ncobmc_mbmi;
   int st_skip, obmc_skip, ncobmc_skip;
   int64_t st_rd, obmc_rd, ncobmc_rd;
@@ -11987,9 +11908,7 @@
 #if CONFIG_WARPED_MOTION
   st_rd += rs;
 #endif
-#if CONFIG_VAR_TX
   memcpy(st_blk_skip, x->blk_skip[0], sizeof(st_blk_skip[0]) * n4);
-#endif
 
   mbmi->motion_mode = OBMC_CAUSAL;
   obmc_rd =
@@ -11997,9 +11916,7 @@
 #if CONFIG_WARPED_MOTION
   obmc_rd += rs;
 #endif
-#if CONFIG_VAR_TX
   memcpy(obmc_blk_skip, x->blk_skip[0], sizeof(obmc_blk_skip[0]) * n4);
-#endif
 
   // Compute the rd cost for ncobmc adaptive weight
   mbmi->motion_mode = NCOBMC_ADAPT_WEIGHT;
@@ -12017,9 +11934,7 @@
       ncobmc_rd +=
           RDCOST(x->rdmult, x->ncobmc_mode_cost[aob][mbmi->ncobmc_mode[1]], 0);
   }
-#if CONFIG_VAR_TX
   memcpy(ncobmc_blk_skip, x->blk_skip[0], sizeof(ncobmc_blk_skip[0]) * n4);
-#endif
 
 #if CONFIG_WARPED_MOTION
   if (is_warp_motion) {
@@ -12036,9 +11951,7 @@
     if (ncobmc_rd < warp_rd) {
       x->skip = ncobmc_skip;
       *mbmi = ncobmc_mbmi;
-#if CONFIG_VAR_TX
       memcpy(x->blk_skip[0], ncobmc_blk_skip, sizeof(ncobmc_blk_skip[0]) * n4);
-#endif
     } else {
       x->skip = warp_skip;
       *mbmi = warp_mbmi;
@@ -12047,23 +11960,17 @@
   if (ncobmc_rd < AOMMIN(st_rd, obmc_rd)) {
     x->skip = ncobmc_skip;
     *mbmi = ncobmc_mbmi;
-#if CONFIG_VAR_TX
     memcpy(x->blk_skip[0], ncobmc_blk_skip, sizeof(ncobmc_blk_skip[0]) * n4);
-#endif
 #endif  // CONFIG_WARPED_MOTION
   } else {
     if (obmc_rd < st_rd) {
       *mbmi = obmc_mbmi;
       x->skip = obmc_skip;
-#if CONFIG_VAR_TX
       memcpy(x->blk_skip[0], obmc_blk_skip, sizeof(obmc_blk_skip[0]) * n4);
-#endif
     } else {
       *mbmi = st_mbmi;
       x->skip = st_skip;
-#if CONFIG_VAR_TX
       memcpy(x->blk_skip[0], st_blk_skip, sizeof(st_blk_skip[0]) * n4);
-#endif
     }
   }
 }
diff --git a/av1/encoder/rdopt.h b/av1/encoder/rdopt.h
index 87b004f..23127e3 100644
--- a/av1/encoder/rdopt.h
+++ b/av1/encoder/rdopt.h
@@ -35,7 +35,6 @@
   (void)tx_size;
   rd_stats->txb_coeff_cost[plane] += txb_coeff_cost;
 
-#if CONFIG_VAR_TX
   {
     const int txb_h = tx_size_high_unit[tx_size];
     const int txb_w = tx_size_wide_unit[tx_size];
@@ -48,7 +47,6 @@
   }
   assert(blk_row < TXB_COEFF_COST_MAP_SIZE);
   assert(blk_col < TXB_COEFF_COST_MAP_SIZE);
-#endif
 }
 #endif
 
diff --git a/av1/encoder/tokenize.c b/av1/encoder/tokenize.c
index d66825b..072c7f5 100644
--- a/av1/encoder/tokenize.c
+++ b/av1/encoder/tokenize.c
@@ -564,7 +564,6 @@
   return result;
 }
 
-#if CONFIG_VAR_TX
 void tokenize_vartx(ThreadData *td, TOKENEXTRA **t, RUN_TYPE dry_run,
                     TX_SIZE tx_size, BLOCK_SIZE plane_bsize, int blk_row,
                     int blk_col, int block, int plane, void *arg) {
@@ -736,7 +735,6 @@
   }
   if (rate) *rate += arg.this_rate;
 }
-#endif  // CONFIG_VAR_TX
 
 void av1_tokenize_sb(const AV1_COMP *cpi, ThreadData *td, TOKENEXTRA **t,
                      RUN_TYPE dry_run, BLOCK_SIZE bsize, int *rate,
diff --git a/av1/encoder/tokenize.h b/av1/encoder/tokenize.h
index e01fe37..5dc39c1 100644
--- a/av1/encoder/tokenize.h
+++ b/av1/encoder/tokenize.h
@@ -70,11 +70,9 @@
 // Note in all the tokenize functions rate if non NULL is incremented
 // with the coefficient token cost only if dry_run = DRY_RUN_COSTCOEFS,
 // otherwise rate is not incremented.
-#if CONFIG_VAR_TX
 void av1_tokenize_sb_vartx(const struct AV1_COMP *cpi, struct ThreadData *td,
                            TOKENEXTRA **t, RUN_TYPE dry_run, int mi_row,
                            int mi_col, BLOCK_SIZE bsize, int *rate);
-#endif
 
 int av1_cost_color_map(const MACROBLOCK *const x, int plane, int block,
                        BLOCK_SIZE bsize, TX_SIZE tx_size, COLOR_MAP_TYPE type);
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake
index 8963efc..8ef057a 100644
--- a/build/cmake/aom_config_defaults.cmake
+++ b/build/cmake/aom_config_defaults.cmake
@@ -203,7 +203,6 @@
 set(CONFIG_TXMG 1 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_UNPOISON_PARTITION_CTX 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_VAR_REFS 0 CACHE NUMBER "AV1 experiment flag.")
-set(CONFIG_VAR_TX 1 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_VAR_TX_NO_TX_MODE 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_WARPED_MOTION 1 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_WEDGE 1 CACHE NUMBER "AV1 experiment flag.")
diff --git a/build/cmake/aom_experiment_deps.cmake b/build/cmake/aom_experiment_deps.cmake
index df34206..68d5ae7 100644
--- a/build/cmake/aom_experiment_deps.cmake
+++ b/build/cmake/aom_experiment_deps.cmake
@@ -120,12 +120,6 @@
     endif ()
   endif ()
 
-  if (CONFIG_VAR_TX_NO_TX_MODE)
-    if (NOT_CONFIG_VAR_TX)
-      change_config_and_warn(CONFIG_VAR_TX 1 CONFIG_VAR_TX_NO_TX_MODE)
-    endif ()
-  endif ()
-
   if (CONFIG_LPF_SB)
     if (CONFIG_LOOPFILTER_LEVEL)
       change_config_and_warn(CONFIG_LOOPFILTER_LEVEL 0 CONFIG_FRAME_SIGN_BIAS)
diff --git a/configure b/configure
index 046d122..29c2b4b 100755
--- a/configure
+++ b/configure
@@ -249,7 +249,6 @@
     fp_mb_stats
     cdef
     cdef_singlepass
-    var_tx
     rect_tx
     rect_tx_ext
     tpl_mv
@@ -515,7 +514,6 @@
       soft_enable dual_filter
       soft_enable motion_var
       soft_enable warped_motion
-      soft_enable var_tx
       soft_enable wedge
       soft_enable compound_segment
       soft_enable interintra
@@ -551,7 +549,6 @@
     enabled lv_map && disable_feature mrc_tx
     enabled coef_interleave && disable_feature mrc_tx
     enabled mrc_tx && enable_feature ext_tx
-    enabled mrc_tx && enable_feature var_tx
     enabled txk_sel && soft_enable lv_map
     enabled ctx1d && soft_enable lv_map
     enabled ctx1d && soft_enable ext_tx
@@ -595,10 +592,6 @@
       disable_feature lgt
       enable_feature lowbitdepth
     fi
-    if enabled var_tx_no_tx_mode && ! enabled var_tx; then
-      log_echo "var_tx_no_tx_mode requires var_tx, so disabling var_tx_no_tx_mode"
-      disable_feature var_tx_no_tx_mode
-    fi
     if enabled ext_partition_types; then
       if enabled fp_mb_stats; then
         log_echo "ext_partition_types not compatible with fp_mb_stats;"
diff --git a/tools/aom_entropy_optimizer.c b/tools/aom_entropy_optimizer.c
index d68c66a..3896ce9 100644
--- a/tools/aom_entropy_optimizer.c
+++ b/tools/aom_entropy_optimizer.c
@@ -648,7 +648,7 @@
 #endif
 
 /* Transform size */
-#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
+#if CONFIG_RECT_TX_EXT
   cts_each_dim[0] = 2;
   optimize_entropy_table(&fc.quarter_tx_size[0], probsfile, 1, cts_each_dim,
                          NULL, 1,
@@ -657,7 +657,6 @@
       &fc.quarter_tx_size[0], probsfile, 1, cts_each_dim,
       "static const aom_cdf_prob default_quarter_tx_size_cdf[CDF_SIZE(2)]");
 #endif
-#if CONFIG_VAR_TX
   cts_each_dim[0] = TXFM_PARTITION_CONTEXTS;
   cts_each_dim[1] = 2;
   optimize_entropy_table(
@@ -668,7 +667,6 @@
       &fc.txfm_partition[0][0], probsfile, 2, cts_each_dim,
       "static const aom_cdf_prob\n"
       "default_txfm_partition_cdf[TXFM_PARTITION_CONTEXTS][CDF_SIZE(2)]");
-#endif
 
   /* Skip flag */
   cts_each_dim[0] = SKIP_CONTEXTS;