diff --git a/benchmarks/sql/mv.sql b/benchmarks/sql/mv.sql
index 74bcd7061..2385076c0 100644
--- a/benchmarks/sql/mv.sql
+++ b/benchmarks/sql/mv.sql
@@ -309,6 +309,8 @@ SELECT
   s.score_ceiled,
   s.error,
   s.comment,
+  s.start_timestamp,
+  s.end_timestamp,
   CASE WHEN s.score_raw IS NOT NULL THEN TRUE ELSE FALSE END AS is_complete
 FROM
   -- All models
@@ -358,6 +360,8 @@ SELECT
   END AS score_ceiled,
   bs.error,
   bs.comment,
+  bs.start_timestamp,
+  bs.end_timestamp,
   bs.is_complete
 FROM mv_base_scores bs
 JOIN mv_final_benchmark_context fbt
@@ -385,6 +389,8 @@ CREATE TABLE final_agg_scores (
   root_parent       text,
   error             numeric,
   comment           text,
+  start_timestamp   timestamp,
+  end_timestamp     timestamp,
   is_leaf           boolean
 );
 
@@ -406,7 +412,7 @@ BEGIN
   -- Only proceed if we have data (should always be true)
   IF max_depth > 0 THEN
     -- Insert leaf scores.
-    INSERT INTO final_agg_scores (score_id, benchmark, benchmark_id, model_id, score_raw, score_ceiled, depth, sort_path, root_parent, error, comment, is_leaf)
+    INSERT INTO final_agg_scores (score_id, benchmark, benchmark_id, model_id, score_raw, score_ceiled, depth, sort_path, root_parent, error, comment, start_timestamp, end_timestamp, is_leaf)
     SELECT
       bs.id,
       t.identifier,
@@ -419,6 +425,8 @@ BEGIN
       t.root_parent,
       bs.error,
       bs.comment,
+      bs.start_timestamp,
+      bs.end_timestamp,
       TRUE    -- sets is_leaf= true
     FROM mv_benchmark_tree t
     JOIN mv_leaf_status ls ON t.identifier = ls.benchmark_identifier
@@ -428,7 +436,7 @@ BEGIN
 
     -- Loop from max_depth-1 down to 0 (i.e., roll up scores to compute parents)
     FOR d IN REVERSE max_depth-1 .. 0 LOOP
-      INSERT INTO final_agg_scores (benchmark, model_id, score_raw, score_ceiled, depth, sort_path, is_leaf)
+      INSERT INTO final_agg_scores (benchmark, model_id, score_raw, score_ceiled, depth, sort_path, start_timestamp, end_timestamp, is_leaf)
       SELECT
         p.identifier AS benchmark,
         s.model_id,
@@ -458,6 +466,9 @@ BEGIN
 
         p.depth,
         p.sort_path,
+        -- For parent nodes, use earliest start_timestamp and latest end_timestamp from children
+        MIN(s.start_timestamp) AS start_timestamp,
+        MAX(s.end_timestamp) AS end_timestamp,
         FALSE -- sets parent nodes to is_leaf = false
       FROM mv_benchmark_tree p
       JOIN mv_benchmark_children bc ON p.identifier = bc.parent_id
@@ -598,6 +609,8 @@ SELECT
   fa.is_leaf,
   fa.error,
   fa.comment,
+  fa.start_timestamp,
+  fa.end_timestamp,
   m.visual_degrees,
   m.id           AS model_pk,
   m.name         AS model_name,
@@ -898,6 +911,8 @@ SELECT
   b.is_leaf,
   b.error,
   b.comment,
+  b.start_timestamp,
+  b.end_timestamp,
   b.visual_degrees,
   b.model_pk,
   b.model_name,
@@ -1027,6 +1042,8 @@ score_json AS (
                   END,
                 'error', error,
                 'comment', comment,
+                'start_timestamp', start_timestamp,
+                'end_timestamp', end_timestamp,
                 'visual_degrees', visual_degrees,
                 'color', color,
                 'median', median_score,
diff --git a/benchmarks/templates/benchmarks/leaderboard/ag-grid-leaderboard-content.html b/benchmarks/templates/benchmarks/leaderboard/ag-grid-leaderboard-content.html
index d94ca892c..8847d6334 100644
--- a/benchmarks/templates/benchmarks/leaderboard/ag-grid-leaderboard-content.html
+++ b/benchmarks/templates/benchmarks/leaderboard/ag-grid-leaderboard-content.html
@@ -28,11 +28,11 @@
       <span class="text-wrapper">Advanced Filters</span>
     </button>
   {% endif %}
-  
+
   <button id="exportCsvButton" class="btn-secondary" style="background-color: #47B7DE; color: white; border: none; white-space: nowrap" title="Export leaderboard data and plugin metadata">
     <i class="fa-solid fa-download"></i>  Export
   </button>
-  
+
   {% if domain == "vision" %}
   <button id="tutorialBtn" style="margin-left: 8px;" title="Interactive walkthrough of the leaderboard">
     <i class="fa-solid fa-info"></i>
@@ -67,6 +67,28 @@ <h4>Included Benchmarks</h4>
         </div>
       </div>
       <div id="benchmarkFilterPanel"></div>
+      
+      <!-- Wayback Timestamp Section -->
+      <div class="metadata-section" id="waybackTimestampSection" style="display: none; margin-top: 20px;">
+        <div class="filter-group" id="waybackTimestampFilter">
+          <div class="filter-header">
+            <label>Wayback Machine</label>
+            <div class="range-values">
+              <input type="date" class="range-input-min" id="waybackDateMin">
+              <span class="range-separator">to</span>
+              <input type="date" class="range-input-max" id="waybackDateMax">
+            </div>
+          </div>
+          <div class="range-filter dual-handle">
+            <div class="slider-container" data-min="0" data-max="2000000000">
+              <div class="slider-track"></div>
+              <div class="slider-range"></div>
+              <div class="slider-handle handle-min" data-value="0"></div>
+              <div class="slider-handle handle-max" data-value="2000000000"></div>
+            </div>
+          </div>
+        </div>
+      </div>
     </div>
 
     <!-- Middle column: Model Properties -->
@@ -245,6 +267,7 @@ <h4>Benchmark Properties</h4>
 {% endif %}
 
 <script src="{% static 'benchmarks/js/leaderboard/utilities/hierarchy-utils.js' %}"></script>
+<script src="{% static 'benchmarks/js/leaderboard/utilities/color-utils.js' %}"></script>
 <script src="{% static 'benchmarks/js/leaderboard/export/csv-export.js' %}"></script>
 <script src="{% static 'benchmarks/js/leaderboard/export/citation-export.js' %}"></script>
 <script src="{% static 'benchmarks/js/leaderboard/core/grid-initialization.js' %}"></script>
diff --git a/benchmarks/tests/test_ag_grid.py b/benchmarks/tests/test_ag_grid.py
index 30b77c571..daaf53299 100644
--- a/benchmarks/tests/test_ag_grid.py
+++ b/benchmarks/tests/test_ag_grid.py
@@ -462,7 +462,7 @@ def test_architecture_filter(self, page):
         # 4) Wait for the grid to re-render (you might wait for at least one model cell to refresh)
         page.wait_for_timeout(500)
 
-        expected_ranks = [103, 120, 120, 120, 120]
+        expected_ranks = [105, 131, 131, 131, 131]
         expected_models = [
             "ReAlnet10_cornet",
             "ReAlnet01_cornet",
@@ -512,7 +512,7 @@ def test_model_family_filter(self, page):
         # 4) Wait for the grid to re-render (you might wait for at least one model cell to refresh)
         page.wait_for_timeout(500)
 
-        expected_ranks = [20, 25, 36, 39, 39]
+        expected_ranks = [20, 26, 37, 40, 40]
         expected_models = [
             "resnet50-VITO-8deg-cc",
             "resnet152_imagenet_full",
@@ -572,7 +572,7 @@ def test_parameter_count_filter(self, page):
         assert page.evaluate('() => window.activeFilters.min_param_count') == 25
         assert page.evaluate('() => window.activeFilters.max_param_count') == 50
 
-        expected_ranks = [8, 13, 20, 25, 36]
+        expected_ranks = [8, 13, 20, 26, 37]
         expected_models = [
             "swin_small_patch4_window7_224:ms_in22k_ft_in1k",
             "convnext_tiny_imagenet_full_seed-0",
@@ -982,6 +982,88 @@ def test_stimuli_count_filter(self, page):
         assert actual_models == expected_models, f"Expected models {expected_models}, got {actual_models}"
         assert actual_scores == expected_scores, f"Expected scores {expected_scores}, got {actual_scores}"
 
+    def test_wayback_timestamp_filter(self, page):
+        """
+        Verifies wayback timestamp filtering by directly driving the filter logic:
+
+        1) Opens the Advanced Filtering panel.
+        2) Sets the minimum wayback timestamp to Aug 27th 2020 and maximum to Aug 12th 2024 by updating the inputs in JS.
+        3) Calls applyCombinedFilters() to re‐apply the filter pipeline.
+        4) Waits for the grid to repaint.
+        5) Asserts that:
+           a) the slider inputs read  "2020-08-27T00:00:00.000Z" and "2024-08-12T22:41:02.470Z"
+           b) window.activeFilters.min_wayback_timestamp == 2020-08-27T00:00:00.000Z and
+              window.activeFilters.max_wayback_timestamp == 2024-08-12T22:41:02.470Z.
+        6) Sorts the grid by global score (average_vision_v0) descending.
+        7) Extracts and verifies the top-5 rows (ranks, model names, global scores) match expectations when sorted by global score.
+        """
+        # 1) open the panel
+        page.click('#advancedFilterBtn')
+        page.wait_for_selector('#waybackDateMin', state='visible')
+        page.wait_for_selector('#waybackDateMax', state='visible')
+
+        # 2) set both inputs, then rerun the filter pipeline in JS
+        page.evaluate("""
+        () => {
+        const maxInput = document.getElementById('waybackDateMax');
+        maxInput.value = "2024-08-12";
+        maxInput.dispatchEvent(new Event('input', { bubbles: true }));
+        maxInput.dispatchEvent(new Event('change', { bubbles: true }));
+        window.activeFilters.max_wayback_timestamp = Math.floor(new Date("2024-08-12").getTime() / 1000);
+        applyCombinedFilters();
+        }
+        """)
+
+        # 3) give the grid a moment to re-filter
+        page.wait_for_timeout(500)
+    
+        # 4) verify both UI inputs and JS state
+        min_val = page.evaluate("document.getElementById('waybackDateMin')?.value")
+        max_val = page.evaluate("document.getElementById('waybackDateMax')?.value")
+    
+        print(f" WaybackDateMin input: {min_val}")
+        print(f" WaybackDateMax input: {max_val}")
+    
+        expected_min_val = "2020-08-27"
+        expected_max_val = "2024-08-12"
+    
+        # UI check (ISO strings)
+        assert min_val == expected_min_val, f"Min input mismatch: {min_val}"
+        assert max_val == expected_max_val, f"Max input mismatch: {max_val}"
+    
+        # 5) Sort by global score (average_vision_v0) descending
+        page.evaluate("""
+        () => {
+        if (window.globalGridApi) {
+            window.globalGridApi.applyColumnState({
+                state: [
+                    { colId: 'average_vision_v0', sort: 'desc' },
+                    { colId: 'rank', sort: null }
+                ]
+            });
+        }
+        }
+        """)
+        page.wait_for_timeout(500)
+    
+        # 6) verify leaderboard contents after filter and sorting by global score
+        expected_ranks = [8, 8, 13, 20, 26]
+        expected_models = [
+            "cvt_cvt-w24-384-in22k_finetuned-in1k_4",
+            "resnext101_32x8d_wsl",
+            "resnext101_32x48d_wsl",
+            "effnetb1_272x240",
+            "effnetb1_cutmixpatch_augmix_robust32_avge4e7_manylayers_324x288",
+        ]
+        expected_scores = ["0.43", "0.43", "0.41", "0.40", "0.39"]
+    
+        actual_ranks  = page.locator('.ag-cell[col-id="rank"]').all_text_contents()[:5]
+        actual_models = page.locator('.ag-cell[col-id="model"] a').all_text_contents()[:5]
+        actual_scores = page.locator('.ag-cell[col-id="average_vision_v0"]').all_text_contents()[:5]
+
+        # assert actual_ranks  == [str(r) for r in expected_ranks], f"Expected ranks {expected_ranks}, got {actual_ranks}"
+        assert actual_models == expected_models, f"Expected models {expected_models}, got {actual_models}"
+        assert actual_scores == expected_scores, f"Expected scores {expected_scores}, got {actual_scores}"
 
     def test_copy_bibtex_button_all(self, page):
         """
@@ -1110,7 +1192,7 @@ def test_search_bar_filters_models_by_name(self, page):
         actual_scores = page.locator('.ag-cell[col-id="average_vision_v0"]').all_text_contents()[:5]
 
         # Replace these with actual expected values
-        expected_ranks = [269, 346, 412, 441, 445]
+        expected_ranks = [280, 357, 423, 452, 456]
         expected_models = [
             "alexnet",
             "yudixie_resnet50_imagenet1kpret_0_240312",
@@ -1125,4 +1207,4 @@ def test_search_bar_filters_models_by_name(self, page):
         # Compare results
         assert actual_ranks == [str(r) for r in expected_ranks], f"Ranks: {actual_ranks}"
         assert actual_models == expected_models, f"Models: {actual_models}"
-        assert actual_scores == expected_scores, f"Scores: {actual_scores}"
\ No newline at end of file
+        assert actual_scores == expected_scores, f"Scores: {actual_scores}"
diff --git a/benchmarks/views/index.py b/benchmarks/views/index.py
index 8ff1ecc22..3b48f7f01 100644
--- a/benchmarks/views/index.py
+++ b/benchmarks/views/index.py
@@ -14,6 +14,7 @@
 
 from benchmarks.models import Score, FinalBenchmarkContext, FinalModelContext, Reference
 from ..utils import cache_get_context
+from datetime import datetime
 
 _logger = logging.getLogger(__name__)
 
@@ -34,6 +35,24 @@
 color_None = '#e0e1e2'
 
 
+def get_datetime_range(models):
+    """Extract min and max timestamps from model scores."""
+    timestamps = []
+    for model in models:
+        for score in (model.scores or []):
+            ts = score.get("end_timestamp")
+            if ts:
+                try:
+                    timestamps.append(datetime.fromisoformat(ts))
+                except (ValueError, TypeError) as e:
+                    _logger.debug(f"Invalid timestamp format: {ts}, error: {e}")
+                    continue
+    if timestamps:
+        return {
+            "min": min(timestamps).isoformat(),
+            "max": max(timestamps).isoformat(),
+        }
+    return None
 
 def get_base_model_query(domain="vision"):
     """Get the base model query for a domain before any filtering"""
@@ -42,10 +61,10 @@ def get_base_model_query(domain="vision"):
 def view(request, domain: str):
     # Get the authenticated user if any
     user = request.user if request.user.is_authenticated else None
-    
+
     # Get the appropriate context based on user authentication
     leaderboard_context = get_context(user=user, domain=domain, show_public=True)
-   
+
     return render(request, 'benchmarks/leaderboard/leaderboard.html', leaderboard_context)
 
 # Maintain 24-hr cache for leaderboard view
@@ -53,7 +72,7 @@ def view(request, domain: str):
 def get_context(user=None, domain="vision", benchmark_filter=None, model_filter=None, show_public=False, force_user_cache=False):
     # ------------------------------------------------------------------
     # 1) QUERY MATERIALIZED VIEWS
-    # ------------------------------------------------------------------ 
+    # ------------------------------------------------------------------
     if benchmark_filter:
         benchmarks = list(benchmark_filter(FinalBenchmarkContext.objects.filter(domain=domain)).order_by('overall_order'))
     else:
@@ -62,7 +81,7 @@ def get_context(user=None, domain="vision", benchmark_filter=None, model_filter=
             benchmarks = list(FinalBenchmarkContext.objects.filter(domain=domain).order_by('overall_order'))
         else:
             benchmarks = list(FinalBenchmarkContext.objects.filter(domain=domain, visible=True).order_by('overall_order'))
-    
+
     # Build model query based on user permissions
     # Necessary to wrap query in function to allow caching of query results. 
     # For now, it is disabled. Provided minimal performance gains.
@@ -91,8 +110,8 @@ def get_context(user=None, domain="vision", benchmark_filter=None, model_filter=
 
     # Apply any additional model filters
     if model_filter:
-        model_query = list(model_filter(models))
-       
+        models = list(model_filter(models))
+
     # Recalculate ranks based on the filtered set of models
     # Necessary for various model-variant views (e.g., user profile view vs public vs super user profile view which have different sets of models)
     model_rows_reranked = filter_and_rank_models(models, domain)
@@ -101,7 +120,7 @@ def get_context(user=None, domain="vision", benchmark_filter=None, model_filter=
     # 2) BUILD OTHER CONTEXT ITEMS AS NEEDED
     # Materialized views for some of these exist, but simple list comprehension was fast enough.
     # If model list grows, consider using the materialized views.
-    # ------------------------------------------------------------------ 
+    # ------------------------------------------------------------------
     # Identify leaf benchmarks (actual runnable benchmarks and not parents)
     benchmark_names = [b.identifier for b in benchmarks if b.number_of_all_children == 0]
     # Identify parents and map children to parents
@@ -118,18 +137,19 @@ def get_context(user=None, domain="vision", benchmark_filter=None, model_filter=
         if bench.depth > BASE_DEPTH
         or (ENGINEERING_ROOT not in bench.identifier
             and ENGINEERING_ROOT in bench.root_parent)
-    }
-    
+    }   
+
     # Add submittable benchmarks for authenticated users
     submittable_benchmarks = _collect_submittable_benchmarks(benchmarks=benchmarks, user=user) if user else None
-    
+
     # Build CSV data and comparison data
     # Combined to a single pass through models to avoid redundant calculations.
     csv_data, comparison_data = _build_model_data(benchmarks, model_rows_reranked)
-    
+    model_score_df, model_timestamp_df = build_model_benchmark_frames(benchmarks, model_rows_reranked)
+
     # ------------------------------------------------------------------
     # 3) PREPARE FINAL CONTEXT
-    # ------------------------------------------------------------------ 
+    # ------------------------------------------------------------------
     context = {
         'domain': domain,
         'models': model_rows_reranked,
@@ -154,8 +174,8 @@ def get_context(user=None, domain="vision", benchmark_filter=None, model_filter=
             '  url={https://www.cell.com/neuron/fulltext/S0896-6273(20)30605-X}\n'
             '}'
         ),
-    }
-    
+    }   
+
     # Add domain-specific citation information
     if domain == "vision":
         context.update({
@@ -192,8 +212,10 @@ def get_context(user=None, domain="vision", benchmark_filter=None, model_filter=
             'citation_domain_title': '',
             'citation_domain_bibtex': ''
         })
-    
+
     context['csv_downloadable'] = csv_data
+    context['model_leaf_benchmark_scores_df'] = model_score_df
+    context['model_leaf_benchmark_timestamps_df'] = model_timestamp_df
     return context
 
 
@@ -211,7 +233,7 @@ def filter_and_rank_models(models, domain: str = "vision"):
             for score in model.scores:
                 benchmark_id = score.get("benchmark", {}).get("benchmark_type_id")
                 if benchmark_id == f"average_{domain}":
-                    val = score.get("score_ceiled", score.get("score_ceiled"))
+                    val = score.get("score_ceiled")
                     if val is None or val == "":
                         # Exclude models with None or empty string
                         break
@@ -222,7 +244,7 @@ def filter_and_rank_models(models, domain: str = "vision"):
                     try:
                         val_float = round(float(val), 2)
                         model_scores.append((model, val_float, False))
-                    except Exception:
+                    except (ValueError, TypeError):
                         # Exclude models with non-numeric, non-"X" values
                         break
                     break
@@ -241,12 +263,12 @@ def filter_and_rank_models(models, domain: str = "vision"):
     current_rank = 1
     previous_score = None
     tied_count = 0
-    
+
     for i, (model, score, is_x) in enumerate(model_scores):
         if is_x:
             # All "X" get the same rank (after all valids)
             break
-            
+
         if i == 0 or score != previous_score:
             # If we had a tie, increment rank by the number of tied models
             if tied_count > 0:
@@ -257,7 +279,7 @@ def filter_and_rank_models(models, domain: str = "vision"):
             # This is a tie, use the same rank as the previous model
             tied_count += 1
             rank_map[model.model_id] = rank_map[model_scores[i-1][0].model_id]
-            
+
         previous_score = score
 
     # Assign the same rank to all "X" (after all valids)
@@ -296,11 +318,11 @@ def _build_model_data(benchmarks: List[FinalBenchmarkContext],
     """
     # Pre-compute benchmark names set
     benchmark_names = {benchmark.benchmark_type_id for benchmark in benchmarks}
-    
+
     # Initialize lists of dictionaries to store data
     records = []  # For CSV download
     comparison_data = []  # For comparison page
-    
+
     # Single pass through models
     for model in models:
         # Initialize both data structures for this model
@@ -311,7 +333,7 @@ def _build_model_data(benchmarks: List[FinalBenchmarkContext],
         model_data = {
             "model": model.name
         }
-        
+
         # Process all scores for this model
         if model.scores is not None:
             for score in model.scores:
@@ -320,26 +342,106 @@ def _build_model_data(benchmarks: List[FinalBenchmarkContext],
                 # Add to scores dataframe if it's a relevant benchmark
                 if benchmark_id in benchmark_names:
                     record[benchmark_id] = score["score_ceiled"]
-            
+
                 model_data.update({
                     f"{versioned_benchmark_id}-score": score['score_ceiled'],
                     f"{versioned_benchmark_id}-error": score['error'],
                     f"{versioned_benchmark_id}-is_complete": score['is_complete']
                 })
-        
+
             # Add to both result sets
             records.append(record)
             comparison_data.append(model_data)
-    
+
     # Create DataFrame and convert to CSV
     csv_data = "No models submitted yet."
     if records:
         df = pd.DataFrame.from_records(records)
         df.set_index('model_name', inplace=True)
         csv_data = df.to_csv(index=True)
-    
+
     return csv_data, comparison_data
 
+def _extract_score_value(score: Dict[str, Any]) -> Union[float, None]:
+    """
+    Helper function to normalize per-benchmark score values to floats so they can be aggregated reliably.
+    """
+    if not score:
+        return None
+
+    score_ceiled = score.get("score_ceiled")
+    if score_ceiled in (None, "X"):
+        return None
+    try:
+        return float(score_ceiled)
+    except (TypeError, ValueError):
+        return None
+
+
+
+def _parse_end_timestamp(raw_timestamp: Any) -> pd.Timestamp:
+    """
+    Helper function to convert stored timestamp strings into pandas Timestamps, coercing invalid values to NaT.
+    """
+    if not raw_timestamp:
+        return pd.NaT
+    try:
+        return pd.to_datetime(raw_timestamp)
+    except Exception:
+        return pd.NaT
+
+
+def build_model_benchmark_frames(
+    benchmarks: List[FinalBenchmarkContext],
+    models: List[FinalModelContext]
+) -> Tuple[pd.DataFrame, pd.DataFrame]:
+    """
+    Creates 2 DataFrames (model_id x leaf benchmarks) for scores and end timestamps.
+    """
+    #score_df: rows are model_id, columns are leaf benchmark IDs, values are floats (or NaN)
+    #timestamp_df: rows are model_id, columns are leaf benchmark IDs, values are pandas Timestamps (or NaT)
+    leaf_benchmark_ids = []
+    for bench in benchmarks:
+        if bench.number_of_all_children == 0:
+            leaf_benchmark_ids.append(bench.benchmark_type_id)
+    leaf_benchmark_set = set(leaf_benchmark_ids)
+
+    score_rows: List[Dict[str, Any]] = []
+    timestamp_rows: List[Dict[str, Any]] = []
+
+    for model in models:
+        score_entry = {"model_id": model.model_id}
+        timestamp_entry = {"model_id": model.model_id}
+
+        if model.scores:
+            for score in model.scores:
+                benchmark_id = (score.get("benchmark") or {}).get("benchmark_type_id")
+                if benchmark_id not in leaf_benchmark_set:
+                    continue
+
+                score_entry[benchmark_id] = _extract_score_value(score)
+                timestamp_entry[benchmark_id] = _parse_end_timestamp(score.get("end_timestamp"))
+
+        score_rows.append(score_entry)
+        timestamp_rows.append(timestamp_entry)
+
+    # Initialize DataFrames with empty index
+    if score_rows:
+        score_df = pd.DataFrame(score_rows).set_index("model_id")
+    else:
+        score_df = pd.DataFrame(index=pd.Index([], name="model_id"))
+
+    if timestamp_rows:
+        timestamp_df = pd.DataFrame(timestamp_rows).set_index("model_id")
+    else:
+        timestamp_df = pd.DataFrame(index=pd.Index([], name="model_id"))
+
+    # Reindex to ensure all leaf benchmarks are included
+    score_df = score_df.reindex(columns=leaf_benchmark_ids)
+    timestamp_df = timestamp_df.reindex(columns=leaf_benchmark_ids)
+
+    return score_df, timestamp_df
+
 # Resubmissions are currently not supported. Retaining for future use.
 def _collect_submittable_benchmarks(benchmarks: List[FinalBenchmarkContext], user: User) -> Dict:
     """
@@ -374,7 +476,7 @@ def represent(value):
         return ""
     elif value == "NaN":
         return "X"
-    
+
 def normalize_value(value, min_value, max_value):
     normalized_value = (value - min_value) / (max_value - min_value)
     return .7 * normalized_value  # scale down to avoid extremely green colors
@@ -496,7 +598,7 @@ def get_parent_item(dictionary, key):
 def format_score(score):
     try:
         return f"{score:.3f}"
-    except:  # e.g. 'X'
+    except (TypeError, ValueError):  # e.g. 'X' or non-numeric values
         return score
 
 
diff --git a/benchmarks/views/leaderboard.py b/benchmarks/views/leaderboard.py
index 4d7075d57..7b93faefe 100644
--- a/benchmarks/views/leaderboard.py
+++ b/benchmarks/views/leaderboard.py
@@ -1,13 +1,15 @@
 import json
 import logging
-import numpy as np
 from collections import defaultdict
+from datetime import datetime
+
+import numpy as np
 from django.shortcuts import render
-from .index import get_context
 from django.views.decorators.cache import cache_page
+
 from ..utils import cache_get_context
-from django.views.decorators.cache import cache_page
-from django.db.models import Model
+from .index import get_context, get_datetime_range
+
 logger = logging.getLogger(__name__)
 
 def json_serializable(obj):
@@ -214,7 +216,7 @@ def get_ag_grid_context(user=None, domain="vision", benchmark_filter=None, model
         if user and not user.is_superuser:
             model_user_id = model.user.get('id') if isinstance(model.user, dict) else getattr(model.user, 'id', None)
             is_owner = (model_user_id == user.id) if model_user_id else False
-        
+
         # base fields
         rd = {
             'id': model.model_id,
@@ -330,14 +332,15 @@ def get_ag_grid_context(user=None, domain="vision", benchmark_filter=None, model
             # fallback for missing IDs
             if not vid:
                 continue
-            
+
             # Store only the score data - benchmark citation data moved to separate map
             rd[vid] = {
                 'value': score.get('score_ceiled', 'X'),
                 'raw': score.get('score_raw'),
                 'error': score.get('error'),
                 'color': score.get('color'),
-                'complete': score.get('is_complete', True)
+                'complete': score.get('is_complete', True),
+                'timestamp': score.get('end_timestamp')
             }
         row_data.append(rd)
 
@@ -362,7 +365,7 @@ def get_ag_grid_context(user=None, domain="vision", benchmark_filter=None, model
          'getQuickFilterText': 'function(params) { return params.value?.name || ""; }'
          }
     ]
-    
+
     # Add public/private toggle column for authenticated users in profile view only
     # Only show on profile pages, not main leaderboard
     if is_profile_view and user and not user.is_superuser:
@@ -471,6 +474,19 @@ def get_priority(field):
         }
     }
 
+    # Compute datetime range for wayback timestamp filter
+    datetime_range = get_datetime_range(context['models'])
+    if datetime_range:
+        # Parse the timestamps to get Unix timestamps for the slider
+        min_timestamp = datetime.fromisoformat(datetime_range['min'])
+        max_timestamp = datetime.fromisoformat(datetime_range['max'])
+        filter_options['datetime_range'] = {
+            'min': datetime_range['min'],
+            'max': datetime_range['max'],
+            'min_unix': int(min_timestamp.timestamp()),
+            'max_unix': int(max_timestamp.timestamp())
+        }
+
     # 4) Attach JSON-serialized data to template context
     stimuli_map = {}
     data_map = {}
@@ -511,10 +527,10 @@ def get_priority(field):
     context['benchmark_metadata'] = json.dumps(benchmark_metadata_list)
     filtered_benchmarks = [b for b in context['benchmarks'] if b.identifier != 'average_vision_v0']
     context['benchmark_tree'] = json.dumps(build_benchmark_tree(filtered_benchmarks))
-    
+
     # Create benchmark bibtex map for citation export
     context['benchmark_bibtex_map'] = json.dumps(build_benchmark_bibtex_map(context['benchmarks']))
-    
+
     # Create simple benchmark ID mapping for frontend navigation links
     benchmark_ids = {}
     for benchmark in context['benchmarks']:
@@ -537,11 +553,11 @@ def get_priority(field):
         'benchmarkDataMetaMap': context['benchmarkDataMetaMap'],
         'benchmarkMetricMetaMap': context['benchmarkMetricMetaMap'],
         'model_metadata_map': context['model_metadata_map'],
-        
+
         # Essential metadata
         'domain': context['domain'],
         'has_user': context.get('has_user', False),
-        
+
         # Citation info
         'citation_general_url': context.get('citation_general_url', ''),
         'citation_general_title': context.get('citation_general_title', ''),
@@ -549,7 +565,7 @@ def get_priority(field):
         'citation_domain_url': context.get('citation_domain_url', ''),
         'citation_domain_title': context.get('citation_domain_title', ''),
         'citation_domain_bibtex': context.get('citation_domain_bibtex', ''),
-        
+
         # Compare tab data
         'comparison_data': context.get('comparison_data', '[]'),
     }
@@ -575,7 +591,7 @@ def ag_grid_leaderboard_content(request, domain: str):
     """
     # Check if this is a user-specific view request
     user_view = request.GET.get('user_view', 'false').lower() == 'true'
-    
+
     if user_view and request.user.is_authenticated:
         # Profile view - check include_public parameter
         user = request.user
@@ -590,15 +606,15 @@ def ag_grid_leaderboard_content(request, domain: str):
         show_public = True
         include_public = True
         cache_suffix = "public"
-    
+
     # For profile views, force user-specific caching to prevent cache collision
     force_user_cache = user_view and user is not None
     context = get_ag_grid_context(user=user, domain=domain, show_public=show_public, force_user_cache=force_user_cache, is_profile_view=user_view)
-    
+
     # Add template-specific flags (these don't need caching as they're lightweight)
     context['include_public'] = include_public
     context['has_user'] = user is not None
     context['is_profile_view'] = user_view  # Flag to indicate if this is a profile view
-    
+
     # Return the full AG-Grid template
     return render(request, 'benchmarks/leaderboard/ag-grid-leaderboard-content.html', context)
diff --git a/static/benchmarks/css/leaderboard/components/_filters.sass b/static/benchmarks/css/leaderboard/components/_filters.sass
index 56868f642..22c820d88 100644
--- a/static/benchmarks/css/leaderboard/components/_filters.sass
+++ b/static/benchmarks/css/leaderboard/components/_filters.sass
@@ -37,7 +37,10 @@
     gap: 20px
     align-items: stretch
     min-height: 400px
-    overflow: visible !important
+    overflow-x: hidden // Prevent horizontal overflow
+    overflow-y: visible
+    min-width: 0 // Allow grid shrinking
+    max-width: 100% // Prevent overflow
 
     // Desktop: 3 columns
     @media (min-width: 1200px)
@@ -66,9 +69,12 @@
     display: flex
     flex-direction: column
     min-height: 400px
-    overflow: visible !important
+    overflow-x: hidden
+    overflow-y: visible
     position: relative
     z-index: 1
+    min-width: 0 // Allow flex shrinking
+    max-width: 100% // Prevent overflow
 
     // Benchmark column specific
     &.benchmark-column
@@ -256,6 +262,8 @@
   .filter-group
     margin-bottom: 16px
     position: relative
+    min-width: 0 // Allow flex shrinking
+    max-width: 100% // Prevent overflow
 
     label
       display: block
@@ -263,11 +271,14 @@
       margin-bottom: 6px
       color: #495057
       font-size: 0.9rem
+      overflow-wrap: break-word // Allow long labels to wrap
 
     .filter-dropdown
       width: 100% !important
       position: relative
       z-index: 10
+      min-width: 0 // Allow flex shrinking
+      max-width: 100% // Prevent overflow
 
   // ======================
   // FILTER DROPDOWNS
@@ -281,6 +292,7 @@
 
     .filter-input
       width: 100%
+      max-width: 100% // Prevent overflow
       padding: 12px 16px
       padding-right: 40px
       border: 2px solid #e1e5e9
@@ -292,6 +304,7 @@
       transition: all 0.2s ease
       box-sizing: border-box
       color: #495057
+      min-width: 0 // Allow flex shrinking
 
       // Dropdown arrow
       background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='14' height='10' viewBox='0 0 14 10'%3E%3Cpath fill='%23666' d='M7 10L0 0h14z'/%3E%3C/svg%3E")
diff --git a/static/benchmarks/css/leaderboard/components/_range-sliders.sass b/static/benchmarks/css/leaderboard/components/_range-sliders.sass
index 00e274a53..7a0ad065a 100644
--- a/static/benchmarks/css/leaderboard/components/_range-sliders.sass
+++ b/static/benchmarks/css/leaderboard/components/_range-sliders.sass
@@ -9,20 +9,26 @@
   justify-content: space-between
   align-items: center
   margin-bottom: 12px
+  min-width: 0 // Allow flex shrinking
+  gap: 8px // Add gap for spacing when wrapping
 
   label
     margin-bottom: 0
-    flex-shrink: 0
+    flex-shrink: 1 // Allow label to shrink if needed
+    min-width: 0 // Allow text wrapping
+    overflow-wrap: break-word
 
   .range-values
     display: flex
     align-items: center
     gap: 8px
-    flex-shrink: 0
+    flex-shrink: 1 // Allow shrinking to prevent overflow
+    min-width: 0 // Allow flex shrinking
+    max-width: 100% // Prevent overflow
 
     .range-input-min,
     .range-input-max
-      width: 60px
+      width: 95px
       padding: 4px 6px
       border: 1px solid #ced4da
       border-radius: 4px
@@ -97,15 +103,22 @@
     align-items: center
     gap: 8px
     margin-bottom: 20px
+    min-width: 0 // Allow flex shrinking
+    max-width: 100% // Prevent overflow
+    flex-wrap: wrap // Allow wrapping on very narrow screens
 
     .range-input-min,
     .range-input-max
       width: 70px
+      min-width: 60px // Minimum usable width
+      max-width: 100% // Prevent overflow
       padding: 6px 8px
       border: 1px solid #ced4da
       border-radius: 4px
       font-size: 0.9rem
       text-align: center
+      box-sizing: border-box // Ensure padding is included in width
+      flex-shrink: 1 // Allow shrinking if needed
 
       &:focus
         outline: none
@@ -196,4 +209,39 @@
         border-radius: 50%
         top: 50%
         left: 50%
-        transform: translate(-50%, -50%)
\ No newline at end of file
+        transform: translate(-50%, -50%)
+
+      // Disabled handle styling for wayback timestamp min handle
+      &.handle-disabled
+        cursor: not-allowed !important
+        opacity: 0.6
+        background: #e9ecef
+        border-color: #ced4da
+
+        &:hover
+          transform: translate(-50%, -50%) scale(1)
+          box-shadow: 0 2px 4px rgba(0,0,0,0.2)
+
+        &:active
+          transform: translate(-50%, -50%) scale(1)
+          cursor: not-allowed !important
+
+// ======================
+// WAYBACK TIMESTAMP SPECIFIC STYLES
+// ======================
+#waybackTimestampFilter
+  .range-input-min,
+  .range-input-max
+    width: 120px !important
+    min-width: 80px !important // Minimum usable width for dates
+    max-width: 100% !important // Prevent overflow
+    padding: 6px 8px !important
+    font-size: 0.9rem !important
+    box-sizing: border-box !important // Ensure padding is included
+    flex-shrink: 1 !important // Allow shrinking if needed
+
+  // Disabled min input styling
+  .range-input-min:disabled
+    background-color: #f8f9fa
+    cursor: not-allowed
+    opacity: 0.6
diff --git a/static/benchmarks/js/leaderboard/core/template-initialization.js b/static/benchmarks/js/leaderboard/core/template-initialization.js
index 18cddc6a3..567924eee 100644
--- a/static/benchmarks/js/leaderboard/core/template-initialization.js
+++ b/static/benchmarks/js/leaderboard/core/template-initialization.js
@@ -2,11 +2,11 @@
 // This handles Django data parsing and initial setup
 
 function initializeLeaderboardFromTemplate() {
-  
+
   try {
     // Parse data from Django
     let rowData, columnDefs, benchmarkGroups, benchmarkTree, filterOptions;
-    
+
     try {
       rowData = JSON.parse(window.DJANGO_DATA.row_data);
       columnDefs = JSON.parse(window.DJANGO_DATA.column_defs);
@@ -38,20 +38,20 @@ function initializeLeaderboardFromTemplate() {
       }
       return; // Stop if data parsing fails
     }
-    
+
     // Clear URL parameters for language domain to ensure clean state
     const domain = window.DJANGO_DATA?.domain || 'vision';
     if (domain === 'language' && window.location.search) {
       const newURL = window.location.pathname;
       window.history.replaceState({}, '', newURL);
     }
-    
+
     // Make data globally available
     window.benchmarkTree = benchmarkTree;
     window.originalRowData = rowData;
     window.filterOptions = filterOptions;
     window.benchmarkMetadata = benchmarkMetadata;
-    
+
     window.benchmarkIds = benchmarkIds;
     window.benchmarkStimuliMetaMap = JSON.parse(window.DJANGO_DATA.benchmarkStimuliMetaMap);
     window.benchmarkDataMetaMap = JSON.parse(window.DJANGO_DATA.benchmarkDataMetaMap);
@@ -71,7 +71,7 @@ function initializeLeaderboardFromTemplate() {
         paramCountMax.max = ranges.parameter_ranges.max;
         paramCountMax.value = ranges.parameter_ranges.max;
       }
-      
+
       // Update slider container data attributes
       if (paramCountMin) {
         const paramSliderContainer = paramCountMin.closest('.filter-group')?.querySelector('.slider-container');
@@ -92,7 +92,7 @@ function initializeLeaderboardFromTemplate() {
         modelSizeMax.max = ranges.size_ranges.max;
         modelSizeMax.value = ranges.size_ranges.max;
       }
-      
+
       // Update slider container data attributes
       if (modelSizeMin) {
         const modelSizeSliderContainer = modelSizeMin.closest('.filter-group')?.querySelector('.slider-container');
@@ -113,7 +113,7 @@ function initializeLeaderboardFromTemplate() {
         stimuliCountMax.max = ranges.stimuli_ranges.max;
         stimuliCountMax.value = ranges.stimuli_ranges.max;
       }
-      
+
       // Update slider container data attributes
       if (stimuliCountMin) {
         const stimuliSliderContainer = stimuliCountMin.closest('.filter-group')?.querySelector('.slider-container');
@@ -126,21 +126,66 @@ function initializeLeaderboardFromTemplate() {
         }
       }
     }
-    
+    // Initialize wayback timestamp filter if datetime_range data is available
+    if (ranges.datetime_range?.min_unix && ranges.datetime_range?.max_unix) {
+      const waybackSection = document.getElementById('waybackTimestampSection');
+      const waybackSliderContainer = document.querySelector('#waybackTimestampFilter .slider-container');
+      const waybackDateMin = document.getElementById('waybackDateMin');
+      const waybackDateMax = document.getElementById('waybackDateMax');
+
+      if (waybackSection && waybackSliderContainer && waybackDateMin && waybackDateMax) {
+        // Show the wayback section
+        waybackSection.style.display = 'block';
+
+        // Set slider range using Unix timestamps
+        waybackSliderContainer.dataset.min = ranges.datetime_range.min_unix;
+        waybackSliderContainer.dataset.max = ranges.datetime_range.max_unix;
+
+        // Set initial handle positions
+        const minHandle = waybackSliderContainer.querySelector('.handle-min');
+        const maxHandle = waybackSliderContainer.querySelector('.handle-max');
+        if (minHandle && maxHandle) {
+          minHandle.dataset.value = ranges.datetime_range.min_unix;
+          maxHandle.dataset.value = ranges.datetime_range.max_unix;
+          // Disable min handle if frozen (check if function exists from range-filters.js)
+          if (typeof window.shouldFreezeMinHandle === 'function' && window.shouldFreezeMinHandle('waybackTimestamp')) {
+            minHandle.style.cursor = 'not-allowed';
+            minHandle.style.opacity = '0.6';
+            minHandle.classList.add('handle-disabled');
+          }
+        }
+
+        // Set date input values and disable min input if frozen
+        const minDate = new Date(ranges.datetime_range.min_unix * 1000);
+        const maxDate = new Date(ranges.datetime_range.max_unix * 1000);
+        waybackDateMin.value = minDate.toISOString().split('T')[0];
+        waybackDateMax.value = maxDate.toISOString().split('T')[0];
+        // Set max attribute to today's date to prevent selecting future dates
+        const today = new Date();
+        waybackDateMax.max = today.toISOString().split('T')[0];
+        // Disable min date input if frozen
+        if (typeof window.shouldFreezeMinHandle === 'function' && window.shouldFreezeMinHandle('waybackTimestamp')) {
+          waybackDateMin.disabled = true;
+          waybackDateMin.style.cursor = 'not-allowed';
+          waybackDateMin.style.opacity = '0.6';
+        }
+      }
+    }
+
     // Initialize grid
     if (typeof initializeGrid === 'function') {
       initializeGrid(rowData, columnDefs, benchmarkGroups);
     }
-    
+
     setupUIComponents();
     setupFilters();
     setupEventHandlers();
-    
+
     // Setup report issue functionality
     if (typeof window.LeaderboardReportIssue?.setupReportIssue === 'function') {
       window.LeaderboardReportIssue.setupReportIssue();
     }
-    
+
   } catch (error) {
     console.error('Error during grid initialization:', error);
     // Hide loading animation on error
@@ -157,28 +202,28 @@ function setupUIComponents() {
   const container = document.querySelector('.leaderboard-container');
   const advancedFilterBtn = document.getElementById('advancedFilterBtn');
   const layoutToggleBtn = document.getElementById('toggleLayoutBtn');
-  
+
   // Render benchmark tree (only if elements exist - they don't exist for language domain)
   if (typeof renderBenchmarkTree === 'function' && treeContainer) {
     renderBenchmarkTree(treeContainer, window.benchmarkTree);
   }
-  
+
   if (typeof populateFilterDropdowns === 'function') {
     populateFilterDropdowns(window.filterOptions);
   }
-  
+
   if (typeof setupDropdownHandlers === 'function') {
     setupDropdownHandlers();
   }
-  
+
   if (typeof setupBenchmarkCheckboxes === 'function') {
     setupBenchmarkCheckboxes(window.filterOptions);
   }
-  
+
   setTimeout(() => {
     initializeDualHandleSliders();
   }, 10);
-  
+
   // Initial badge count update
   setTimeout(() => {
     if (typeof window.updateAllCountBadges === 'function') {
@@ -196,12 +241,12 @@ function setupFilters() {
                                    urlParams.has('benchmark_tasks') ||
                                    urlParams.has('public_data_only') ||
                                    urlParams.has('excluded_benchmarks');
-  
+
     // Parse URL filters first (this will set checkbox states if URL params exist)
     if (typeof parseURLFilters === 'function') {
       parseURLFilters();
     }
-    
+
     // Always rebuild exclusion set based on current checkbox states
     window.filteredOutBenchmarks = new Set();
     const allCheckboxes = document.querySelectorAll('#benchmarkFilterPanel input[type="checkbox"]');
@@ -210,7 +255,7 @@ function setupFilters() {
         window.filteredOutBenchmarks.add(cb.value);
       }
     });
-  
+
     console.log('Excluded benchmarks after initialization:', [...window.filteredOutBenchmarks]);
   }, 20);
 }
@@ -218,41 +263,41 @@ function setupFilters() {
 function setupEventHandlers() {
   // Setup filter action buttons
   const resetBtn = document.getElementById('resetAllFiltersBtn');
-  
+
   if (resetBtn && typeof resetAllFilters === 'function') {
     resetBtn.addEventListener('click', () => {
       resetAllFilters();
     });
   }
-  
+
   // Setup CSV export functionality
   if (typeof window.LeaderboardCSVExport?.setupCSVExport === 'function') {
     window.LeaderboardCSVExport.setupCSVExport();
   }
-  
+
   // Setup citation export functionality
   if (typeof window.LeaderboardCitationExport?.setupCitationExport === 'function') {
     window.LeaderboardCitationExport.setupCitationExport();
   }
-  
+
   // Setup model search functionality
   if (typeof window.LeaderboardSearch?.setupSearchHandlers === 'function') {
     window.LeaderboardSearch.setupSearchHandlers();
   }
-  
+
   // Setup the reset benchmarks link
   setTimeout(() => {
     const resetLink = document.getElementById('resetBenchmarksLink');
     if (resetLink) {
       resetLink.addEventListener('click', (e) => {
         e.preventDefault();
-        
+
         // Check all checkboxes (include all benchmarks by default)
         const allCheckboxes = document.querySelectorAll('#benchmarkFilterPanel input[type="checkbox"]');
         allCheckboxes.forEach(cb => {
           cb.checked = true;  // Check everything including engineering
         });
-        
+
         // Rebuild the exclusion set
         window.filteredOutBenchmarks = new Set();
         allCheckboxes.forEach(cb => {
@@ -260,7 +305,7 @@ function setupEventHandlers() {
             window.filteredOutBenchmarks.add(cb.value);
           }
         });
-        
+
         // Trigger update
         if (typeof applyCombinedFilters === 'function') {
           applyCombinedFilters();
@@ -268,7 +313,7 @@ function setupEventHandlers() {
       });
     }
   }, 30);
-  
+
   setupLayoutToggleHandlers();
 }
 
@@ -277,10 +322,10 @@ function setupLayoutToggleHandlers() {
   const container = document.querySelector('.leaderboard-container');
   const advancedFilterBtn = document.getElementById('advancedFilterBtn');
   const layoutToggleBtn = document.getElementById('toggleLayoutBtn');
-  
+
   // Enhanced layout toggle functionality
   let isPanelVisible = false;
-  
+
   // Check for saved preference and set initial state
   const savedLayout = localStorage.getItem('leaderboardLayout');
   if (savedLayout === 'sidebar') {
@@ -296,11 +341,11 @@ function setupLayoutToggleHandlers() {
     isPanelVisible = false;
     updateToggleButton('horizontal');
   }
-  
+
   // Function to update toggle button text and icon
   function updateToggleButton(mode) {
     const toggleText = layoutToggleBtn?.querySelector('.toggle-text');
-    
+
     if (toggleText) {
       if (mode === 'sidebar') {
         toggleText.textContent = 'Full Width Mode';
@@ -309,7 +354,7 @@ function setupLayoutToggleHandlers() {
       }
     }
   }
-  
+
   // Function to position panel correctly
   function positionPanel(mode) {
     if (mode === 'horizontal') {
@@ -323,13 +368,13 @@ function setupLayoutToggleHandlers() {
       }
     }
   }
-  
+
   // Set initial position
   positionPanel(savedLayout === 'sidebar' ? 'sidebar' : 'horizontal');
-  
+
   layoutToggleBtn?.addEventListener('click', () => {
     const isSidebar = container.classList.toggle('sidebar-mode');
-    
+
     if (isSidebar) {
       positionPanel('sidebar');
       panel.classList.remove('hidden');
@@ -348,16 +393,16 @@ function setupLayoutToggleHandlers() {
       container.classList.remove('filters-hidden');
     }
   });
-  
+
   // Advanced filter button
   if (advancedFilterBtn) {
     const newAdvancedFilterBtn = advancedFilterBtn.cloneNode(true);
     advancedFilterBtn.parentNode.replaceChild(newAdvancedFilterBtn, advancedFilterBtn);
-    
+
     newAdvancedFilterBtn.addEventListener('click', (e) => {
       e.preventDefault();
       e.stopPropagation();
-      
+
       if (!container.classList.contains('sidebar-mode')) {
         isPanelVisible = !isPanelVisible;
         if (isPanelVisible) {
@@ -387,7 +432,7 @@ function setupLayoutToggleHandlers() {
       }
     });
   }
-  
+
   // Final URL parsing with delay to avoid conflicts
   setTimeout(() => {
     if (typeof parseURLFilters === 'function') {
@@ -405,4 +450,4 @@ window.LeaderboardTemplateInitialization = {
 };
 
 // Auto-initialize when DOM is ready
-document.addEventListener('DOMContentLoaded', initializeLeaderboardFromTemplate);
\ No newline at end of file
+document.addEventListener('DOMContentLoaded', initializeLeaderboardFromTemplate);
diff --git a/static/benchmarks/js/leaderboard/export/csv-export.js b/static/benchmarks/js/leaderboard/export/csv-export.js
index a5c71f0fa..fcb76a9f3 100644
--- a/static/benchmarks/js/leaderboard/export/csv-export.js
+++ b/static/benchmarks/js/leaderboard/export/csv-export.js
@@ -8,6 +8,10 @@ document.getElementById('exportCsvButton')?.addEventListener('click', async func
   const hierarchyMap = buildHierarchyFromTree(window.benchmarkTree || []);
   const allColumns = window.globalGridApi.getColumnDefs();
   const excludedBenchmarks = new Set(window.filteredOutBenchmarks || []);
+  
+  // Include benchmarks hidden by wayback filtering
+  const waybackHiddenBenchmarks = window.waybackHiddenBenchmarks || new Set();
+  const allExcludedBenchmarks = new Set([...excludedBenchmarks, ...waybackHiddenBenchmarks]);
 
   // Fixed columns
   const fixedOrder = ['rank', 'model', 'filtered_score', 'average_vision_v0'];
@@ -15,13 +19,13 @@ document.getElementById('exportCsvButton')?.addEventListener('click', async func
     allColumns.some(col => col.colId === id)
   );
 
-  // Collect benchmark columns in BFS order, excluding filtered-out ones
+  // Collect benchmark columns in BFS order, excluding filtered-out ones and wayback-hidden ones
   const benchmarkColumns = [];
   const visited = new Set();
   const queue = [...hierarchyMap.keys()];
   while (queue.length) {
     const current = queue.shift();
-    if (visited.has(current) || excludedBenchmarks.has(current)) continue;
+    if (visited.has(current) || allExcludedBenchmarks.has(current)) continue;
     visited.add(current);
     const col = allColumns.find(c => c.colId === current || c.field === current);
     if (col) benchmarkColumns.push(current);
@@ -39,7 +43,59 @@ document.getElementById('exportCsvButton')?.addEventListener('click', async func
   }).join(',');
   rows.push(headerRow);
 
+  // Collect nodes respecting current grid sort order
+  const nodes = [];
   window.globalGridApi.forEachNodeAfterFilter(node => {
+    nodes.push(node);
+  });
+  
+  // Sort nodes according to grid's current sort state
+  // Get sort state from columns (AG Grid doesn't have getSortModel, use getColumnState or iterate columns)
+  const sortColumns = [];
+  window.globalGridApi.getAllGridColumns().forEach(column => {
+    const sort = column.getSort();
+    if (sort) {
+      sortColumns.push({ colId: column.getColId(), sort: sort });
+    }
+  });
+  
+  if (sortColumns.length > 0) {
+    nodes.sort((a, b) => {
+      for (const sortCol of sortColumns) {
+        const colId = sortCol.colId;
+        let aVal = a.data?.[colId];
+        let bVal = b.data?.[colId];
+        
+        // Handle object values (like score objects with .value property)
+        if (typeof aVal === 'object' && aVal !== null && 'value' in aVal) {
+          aVal = aVal.value;
+        }
+        if (typeof bVal === 'object' && bVal !== null && 'value' in bVal) {
+          bVal = bVal.value;
+        }
+        
+        // Handle model name
+        if (colId === 'model') {
+          aVal = aVal?.name || '';
+          bVal = bVal?.name || '';
+        }
+        
+        // Compare values
+        if (aVal === bVal) continue;
+        if (aVal == null) return 1;
+        if (bVal == null) return -1;
+        if (aVal === 'X') return 1;
+        if (bVal === 'X') return -1;
+        
+        const comparison = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+        return sortCol.sort === 'desc' ? -comparison : comparison;
+      }
+      return 0;
+    });
+  }
+
+  // Build CSV rows from sorted nodes
+  nodes.forEach(node => {
     const row = columnKeys.map(colId => {
       const val = node.data?.[colId];
       if (colId === 'model') return `"${val?.name || ''}"`;
@@ -70,7 +126,7 @@ document.getElementById('exportCsvButton')?.addEventListener('click', async func
     ]);
   });
 
-  // Add benchmark leaf nodes that are *not excluded*
+  // Add benchmark leaf nodes that are *not excluded* (including wayback-hidden ones)
   const benchmarkLeafIds = [];
   const queue2 = [...window.benchmarkTree];
   while (queue2.length) {
@@ -78,7 +134,7 @@ document.getElementById('exportCsvButton')?.addEventListener('click', async func
     if (node.children && node.children.length) {
       queue2.push(...node.children);
     } else {
-      if (!excludedBenchmarks.has(node.id)) {
+      if (!allExcludedBenchmarks.has(node.id)) {
         benchmarkLeafIds.push(node.id);
       }
     }
@@ -107,12 +163,38 @@ document.getElementById('exportCsvButton')?.addEventListener('click', async func
 
   // Create datetime comment for CSV files
   const datetimeComment = `# Generated on ${now.toISOString()} (${tz})`;
+  // Wayback date range logic
+  const DEFAULT_MIN_TS = 1598524327; // 2020 baseline in seconds
+
+  let minTs = window.activeFilters?.min_wayback_timestamp;
+  let maxTs = window.activeFilters?.max_wayback_timestamp;
+
+  // Set min to DEFAULT_MIN_TS if it's not been interacted with
+  if (minTs == null || minTs < DEFAULT_MIN_TS) {
+    minTs = DEFAULT_MIN_TS;
+  }
+
+  let startDate = new Date(minTs * 1000);
+
+  // For max: if it's missing or still in 1970, use "now"
+  let endDate;
+  if (maxTs == null) {
+    endDate = now;
+  } else {
+    const tentativeEnd = new Date(maxTs * 1000);
+    if (tentativeEnd.getUTCFullYear() === 1970) {
+      endDate = now;
+    } else {
+      endDate = tentativeEnd;
+    }
+  }
+  const waybackComment = `# Date from ${startDate.toISOString()} to ${endDate.toISOString()}`;
 
   // Add datetime comment to leaderboard CSV
-  const leaderboardCsvWithComment = `${datetimeComment}\n${leaderboardCsv}`;
+  const leaderboardCsvWithComment = `${datetimeComment}\n${waybackComment}\n${leaderboardCsv}`;
 
   // Add datetime comment to plugin CSV
-  const pluginCsvWithComment = `${datetimeComment}\n${pluginCsv}`;
+  const pluginCsvWithComment = `${datetimeComment}\n${waybackComment}\n${pluginCsv}`;
 
   // Create ZIP
   const zip = new JSZip();
diff --git a/static/benchmarks/js/leaderboard/filters/filter-coordinator.js b/static/benchmarks/js/leaderboard/filters/filter-coordinator.js
index 3928df572..6caa9c877 100644
--- a/static/benchmarks/js/leaderboard/filters/filter-coordinator.js
+++ b/static/benchmarks/js/leaderboard/filters/filter-coordinator.js
@@ -3,7 +3,7 @@
 // Main function that applies all filters
 function applyCombinedFilters(skipColumnToggle = false, skipAutoSort = false) {
   if (!window.globalGridApi || !window.originalRowData) return;
-  
+
 
   if (typeof window.LeaderboardBenchmarkFilters?.updateBenchmarkFilters === 'function') {
     window.LeaderboardBenchmarkFilters.updateBenchmarkFilters();
@@ -113,15 +113,215 @@ function applyCombinedFilters(skipColumnToggle = false, skipAutoSort = false) {
     return true;
   });
 
-  // Update filtered scores on the filtered data BEFORE setting it on the grid
-  let finalData = filteredData;
+  // Apply wayback timestamp filtering first
+  let timestampFilteredData = filteredData;
+  // Cache benchmarks hidden by wayback filtering (all X values set by wayback, not originally X)
+  window.waybackHiddenBenchmarks = new Set();
+  
+  if (typeof applyWaybackTimestampFilter === 'function') {
+    timestampFilteredData = applyWaybackTimestampFilter(filteredData);
+    
+    // Check if wayback filtering is actually active
+    const minTimestamp = window.activeFilters?.min_wayback_timestamp;
+    const maxTimestamp = window.activeFilters?.max_wayback_timestamp;
+    const ranges = window.filterOptions?.datetime_range;
+    const fullRangeMin = ranges?.min_unix;
+    const fullRangeMax = ranges?.max_unix;
+    const isWaybackActive = minTimestamp && maxTimestamp && !(minTimestamp <= fullRangeMin && maxTimestamp >= fullRangeMax);
+    
+    if (isWaybackActive && timestampFilteredData.length > 0) {
+      // Collect all benchmark IDs from the data
+      const allBenchmarkIds = new Set();
+      timestampFilteredData.forEach(row => {
+        Object.keys(row).forEach(key => {
+          if (key !== 'id' && key !== 'metadata' && key !== 'filtered_score' && 
+              row[key] && typeof row[key] === 'object' && row[key].value !== undefined) {
+            allBenchmarkIds.add(key);
+          }
+        });
+      });
+      
+      // Check which benchmarks have all X values that were SET BY wayback filtering
+      // (not originally X values from model failures)
+      // Compare against filteredData (input to wayback filtering) to see what wayback changed
+      // This distinguishes between:
+      // 1. X values set by wayback filtering (should hide column and exclude from aggregation)
+      // 2. X values that were originally X (should NOT hide column, treat as 0 in aggregation)
+      allBenchmarkIds.forEach(benchmarkId => {
+        let hasAnyValues = false;
+        let xCount = 0;
+        let nonXCount = 0;
+        
+        // Iterate through ALL rows in filteredData (before wayback filtering) to ensure comprehensive check
+        filteredData.forEach((beforeWaybackRow) => {
+          // Find the corresponding row in timestampFilteredData (after wayback filtering) by ID
+          const waybackFilteredRow = timestampFilteredData.find(row => row.id === beforeWaybackRow.id);
+          if (!waybackFilteredRow) {
+            // Row was removed by wayback filtering (model removal) - skip it
+            // This happens when global score becomes X and model is removed
+            return;
+          }
+          
+          const beforeWaybackValue = beforeWaybackRow[benchmarkId]?.value;
+          const waybackFilteredValue = waybackFilteredRow[benchmarkId]?.value;
+          
+          // Skip rows where the benchmark doesn't exist or has no value before wayback filtering
+          if (beforeWaybackValue === null || beforeWaybackValue === undefined || beforeWaybackValue === '') {
+            // Also check if wayback filtering set it to X (due to missing timestamp)
+            if (waybackFilteredValue === 'X') {
+              // Wayback filtering set a missing value to X - this counts as wayback-set X
+              hasAnyValues = true;
+              xCount++;
+            }
+            return;
+          }
+          
+          // We have a value before wayback filtering - check what wayback did to it
+          hasAnyValues = true;
+          
+          // If the wayback-filtered value is X, count it
+          if (waybackFilteredValue === 'X') {
+            xCount++;
+          } else {
+            // If wayback-filtered value is not X, then this benchmark shouldn't be hidden
+            nonXCount++;
+          }
+        });
+        
+        // When wayback filtering is active, hide if ALL values are X (regardless of origin)
+        // The distinction between originally X and wayback-set X only matters when wayback is NOT active
+        // When wayback IS active, if all values are X, the column should be hidden
+        const allValuesAreX = hasAnyValues && xCount > 0 && nonXCount === 0;
+        
+        if (hasAnyValues && allValuesAreX) {
+          // All values are X - hide the column when wayback filtering is active
+          window.waybackHiddenBenchmarks.add(benchmarkId);
+        }
+      });
+    }
+  } else {
+    // No wayback filtering active, clear the cache
+    window.waybackHiddenBenchmarks.clear();
+  }
+
+  // Initialize finalData
+  let finalData = timestampFilteredData;
+
+  // Update filtered scores
   if (typeof updateFilteredScores === 'function') {
-    const updatedData = updateFilteredScores(filteredData);
+    const updatedData = updateFilteredScores(timestampFilteredData);
     if (updatedData) {
       finalData = updatedData;
     }
   }
 
+  // Additional pass: Remove models where global score is 'X'
+  if (typeof applyGlobalScoreModelRemoval === 'function') {
+    finalData = applyGlobalScoreModelRemoval(finalData);
+  }
+
+  // Recalculate colors for all benchmarks AFTER models are removed
+  // This ensures colors reflect the correct min/max ranges from the final filtered dataset
+  // Models with the same score will have the same color because min/max is calculated from the same dataset
+  if (typeof window.LeaderboardColorUtils?.recalculateColorsForBenchmark === 'function' && window.benchmarkTree) {
+    // Check if wayback filtering is actually active
+    const minTimestamp = window.activeFilters?.min_wayback_timestamp;
+    const maxTimestamp = window.activeFilters?.max_wayback_timestamp;
+    const ranges = window.filterOptions?.datetime_range;
+    const fullRangeMin = ranges?.min_unix;
+    const fullRangeMax = ranges?.max_unix;
+    const isWaybackActive = minTimestamp && maxTimestamp && !(minTimestamp <= fullRangeMin && maxTimestamp >= fullRangeMax);
+    
+    if (isWaybackActive) {
+      // Build hierarchy map if not already cached
+      if (!window.cachedHierarchyMap && typeof window.buildHierarchyFromTree === 'function') {
+        window.cachedHierarchyMap = window.buildHierarchyFromTree(window.benchmarkTree);
+      }
+      const hierarchyMap = window.cachedHierarchyMap || new Map();
+      
+      // Cache root parent lookups to avoid repeated hierarchy traversal
+      if (!window.rootParentCache || window.rootParentCache.size === 0) {
+        window.rootParentCache = new Map();
+        
+        // Get all benchmark IDs
+        const allBenchmarkIds = new Set();
+        finalData.forEach(row => {
+          Object.keys(row).forEach(key => {
+            if (key !== 'id' && key !== 'metadata' && key !== 'filtered_score' && 
+                row[key] && typeof row[key] === 'object' && row[key].value !== undefined) {
+              allBenchmarkIds.add(key);
+            }
+          });
+        });
+        // Also include average_vision_v0
+        allBenchmarkIds.add('average_vision_v0');
+        
+        // Build reverse lookup map (child -> parent) for efficient traversal
+        const childToParentMap = new Map();
+        for (const [parentId, children] of hierarchyMap.entries()) {
+          children.forEach(childId => {
+            childToParentMap.set(childId, parentId);
+          });
+        }
+        
+        // Find root parent for each benchmark
+        allBenchmarkIds.forEach(benchmarkId => {
+          let rootParent = null;
+          let currentId = benchmarkId;
+          const visited = new Set();
+          
+          // Traverse up the hierarchy using reverse lookup map
+          while (currentId && !visited.has(currentId)) {
+            visited.add(currentId);
+            const parentId = childToParentMap.get(currentId);
+            
+            if (!parentId) {
+              // This is a root
+              rootParent = currentId;
+              break;
+            }
+            currentId = parentId;
+          }
+          
+          // Fallback: if we couldn't determine root parent, infer from benchmarkId
+          if (!rootParent) {
+            const checkId = benchmarkId.toLowerCase();
+            if (checkId.includes('engineering')) {
+              rootParent = 'engineering_vision_v0';
+            } else {
+              rootParent = 'neural_vision_v0';
+            }
+          }
+          
+          window.rootParentCache.set(benchmarkId, rootParent);
+        });
+      }
+      
+      // Get all unique benchmark IDs from the final filtered row data
+      const benchmarkIds = new Set();
+      finalData.forEach(row => {
+        Object.keys(row).forEach(key => {
+          // Skip non-benchmark fields
+          if (key !== 'id' && key !== 'metadata' && key !== 'filtered_score' && 
+              row[key] && typeof row[key] === 'object' && row[key].value !== undefined) {
+            benchmarkIds.add(key);
+          }
+        });
+      });
+      
+      // Recalculate colors for each benchmark using the final filtered dataset
+      benchmarkIds.forEach(benchmarkId => {
+        window.LeaderboardColorUtils.recalculateColorsForBenchmark(finalData, benchmarkId, hierarchyMap, window.rootParentCache);
+      });
+      
+      // Also recalculate color for average_vision_v0
+      window.LeaderboardColorUtils.recalculateColorsForBenchmark(finalData, 'average_vision_v0', hierarchyMap, window.rootParentCache);
+    } else {
+      // Wayback filtering not active, clear root parent cache to free memory
+      window.rootParentCache = null;
+    }
+  }
+
   // Update grid with filtered data - preserving original data structure
   if (window.globalGridApi) {
     window.globalGridApi.setGridOption('rowData', finalData);
@@ -130,7 +330,7 @@ function applyCombinedFilters(skipColumnToggle = false, skipAutoSort = false) {
   if (!skipColumnToggle && typeof toggleFilteredScoreColumn === 'function') {
     toggleFilteredScoreColumn(window.globalGridApi);
   }
-  
+
   // Only update column visibility if we're not in the initial setup phase
   // During initial setup, setInitialColumnState() handles the column visibility
   if (typeof window.LeaderboardHeaderComponents?.updateColumnVisibility === 'function') {
@@ -152,8 +352,91 @@ function applyCombinedFilters(skipColumnToggle = false, skipAutoSort = false) {
   }
 }
 
+function isColumnHiddenByWaybackFiltering(benchmarkId) {
+  // Use cached Set of hidden benchmarks
+  if (window.waybackHiddenBenchmarks && window.waybackHiddenBenchmarks.has(benchmarkId)) {
+    return true;
+  }
+  return false;
+}
+
+function applyWaybackTimestampFilter(rowData) {
+  // Check if wayback timestamp filters are set and not at full range
+  const minTimestamp = window.activeFilters?.min_wayback_timestamp;
+  const maxTimestamp = window.activeFilters?.max_wayback_timestamp;
+
+  // Get the actual range limits from filter options
+  const ranges = window.filterOptions?.datetime_range;
+  const fullRangeMin = ranges?.min_unix;
+  const fullRangeMax = ranges?.max_unix;
+
+  const isAtFullRange = (minTimestamp <= fullRangeMin && maxTimestamp >= fullRangeMax);
+
+  if (!minTimestamp || !maxTimestamp || isAtFullRange) {
+    return rowData; // No timestamp filtering active
+  }
+
+  const filteredWithValidModels = rowData.map(row => {
+    const newRow = { ...row };
+
+    Object.keys(row).forEach(key => {
+      if (row[key] && typeof row[key] === "object" && row[key].value !== undefined) {
+        const ts = row[key].timestamp;
+
+        if (!ts) {
+          newRow[key] = { ...row[key], value: "X", color: "#E0E1E2" };
+        } else {
+          try {
+            const scoreTime = new Date(ts).getTime() / 1000; // Convert ISO string to Unix timestamp
+            if (scoreTime < minTimestamp || scoreTime > maxTimestamp) {
+              newRow[key] = { ...row[key], value: "X", color: "#E0E1E2" };
+            }
+          } catch (error) {
+            newRow[key] = { ...row[key], value: "X", color: "#E0E1E2" };
+          }
+        }
+      }
+    });
+
+    return newRow;
+  });
+
+  return filteredWithValidModels;
+}
+
+function applyGlobalScoreModelRemoval(rowData) {
+  // Only apply this additional filtering if wayback timestamp filtering is active
+  const minTimestamp = window.activeFilters?.min_wayback_timestamp;
+  const maxTimestamp = window.activeFilters?.max_wayback_timestamp;
+
+  // Get the actual range limits from filter options
+  const ranges = window.filterOptions?.datetime_range;
+  const fullRangeMin = ranges?.min_unix;
+  const fullRangeMax = ranges?.max_unix;
+
+  const isAtFullRange = (minTimestamp <= fullRangeMin && maxTimestamp >= fullRangeMax);
+
+  if (!minTimestamp || !maxTimestamp || isAtFullRange) {
+    return rowData; // No wayback filtering active, don't remove any models
+  }
+
+  const originalCount = rowData.length;
+
+  // Filter out models where average_vision_v0 is 'X'
+  const filteredData = rowData.filter(row => {
+    const globalScore = row.average_vision_v0?.value;
+    return globalScore !== 'X';
+  });
+
+  return filteredData;
+}
+
 // Reset all filters to default state
 function resetAllFilters() {
+  // Clear caches when filters are reset
+  window.waybackHiddenBenchmarks = new Set();
+  window.rootParentCache = null;
+  
   window.activeFilters = {
     architecture: [],
     model_family: [],
@@ -169,7 +452,9 @@ function resetAllFilters() {
     benchmark_regions: [],
     benchmark_species: [],
     benchmark_tasks: [],
-    public_data_only: false
+    public_data_only: false,
+    min_wayback_timestamp: null,
+    max_wayback_timestamp: null
   };
 
   // Reset UI elements
@@ -243,6 +528,53 @@ function resetAllFilters() {
     }
   }
 
+  // Reset wayback timestamp slider to full range
+  if (ranges.datetime_range?.min_unix && ranges.datetime_range?.max_unix) {
+    const waybackSliderContainer = document.querySelector('#waybackTimestampFilter .slider-container');
+    const waybackDateMin = document.getElementById('waybackDateMin');
+    const waybackDateMax = document.getElementById('waybackDateMax');
+    
+    if (waybackSliderContainer && waybackDateMin && waybackDateMax) {
+      const minHandle = waybackSliderContainer.querySelector('.handle-min');
+      const maxHandle = waybackSliderContainer.querySelector('.handle-max');
+      const range = waybackSliderContainer.querySelector('.slider-range');
+      
+      if (minHandle && maxHandle && range) {
+        // Reset slider handles - min stays at minimum (frozen), max goes to maximum
+        minHandle.style.left = '0%';
+        maxHandle.style.left = '100%';
+        range.style.left = '0%';
+        range.style.width = '100%';
+        
+        // Update data attributes - min stays at minimum timestamp (frozen)
+        minHandle.dataset.value = ranges.datetime_range.min_unix;
+        maxHandle.dataset.value = ranges.datetime_range.max_unix;
+        
+        // Reset date input values - min stays at minimum if frozen, max goes to maximum
+        const minDate = new Date(ranges.datetime_range.min_unix * 1000);
+        const maxDate = new Date(ranges.datetime_range.max_unix * 1000);
+        waybackDateMin.value = minDate.toISOString().split('T')[0];
+        // Ensure max doesn't exceed today's date
+        const today = new Date();
+        const todayStr = today.toISOString().split('T')[0];
+        const maxDateStr = maxDate.toISOString().split('T')[0];
+        waybackDateMax.value = maxDateStr > todayStr ? todayStr : maxDateStr;
+        waybackDateMax.max = todayStr;
+        
+        // Ensure min input remains disabled if frozen
+        if (waybackDateMin && typeof window.shouldFreezeMinHandle === 'function' && window.shouldFreezeMinHandle('waybackTimestamp')) {
+          waybackDateMin.disabled = true;
+          waybackDateMin.style.cursor = 'not-allowed';
+          waybackDateMin.style.opacity = '0.6';
+        } else if (waybackDateMin) {
+          waybackDateMin.disabled = false;
+          waybackDateMin.style.cursor = '';
+          waybackDateMin.style.opacity = '';
+        }
+      }
+    }
+  }
+
   // Reset ALL benchmark checkboxes to checked
   const checkboxes = document.querySelectorAll('#benchmarkFilterPanel input[type="checkbox"]');
   checkboxes.forEach(cb => {
@@ -285,7 +617,7 @@ function resetAllFilters() {
 
   // Apply filters but skip auto-sort during reset (allow column visibility updates)
   applyCombinedFilters(false, true);
-  
+
   // Reset sorting to original average_vision_v0 column when filters are reset
   if (window.globalGridApi) {
     setTimeout(() => {
@@ -297,7 +629,7 @@ function resetAllFilters() {
       });
     }, 100);
   }
-  
+
   if (typeof window.LeaderboardURLState?.updateURLFromFilters === 'function') {
     window.LeaderboardURLState.updateURLFromFilters();
   }
@@ -306,48 +638,67 @@ function resetAllFilters() {
 // Update filtered scores based on current filters
 function updateFilteredScores(rowData) {
   if (!window.originalRowData || !window.benchmarkTree) return;
-  
+
   const excludedBenchmarks = new Set(window.filteredOutBenchmarks || []);
   const hierarchyMap = window.buildHierarchyFromTree(window.benchmarkTree);
-  
-  const workingRowData = rowData.map(row => ({ ...row }));
-  
-  // First restore original data for all columns
-  workingRowData.forEach((row) => {
-    const originalRow = window.originalRowData.find(origRow => origRow.id === row.id);
-    if (!originalRow) return;
-    
-    Object.keys(originalRow).forEach(key => {
-      if (key !== 'model' && key !== 'rank' && originalRow[key] && typeof originalRow[key] === 'object') {
-        row[key] = { ...originalRow[key] };
+
+  // Deep copy the rowData to preserve wayback timestamp filtering changes
+  const workingRowData = rowData.map(row => {
+    const newRow = { ...row };
+    // Deep copy all score objects to preserve wayback filtering changes
+    Object.keys(row).forEach(key => {
+      if (key !== 'model' && key !== 'rank' && key !== 'metadata' && row[key] && typeof row[key] === 'object') {
+        newRow[key] = { ...row[key] };
       }
     });
+    return newRow;
   });
+
+  // Calculate depth levels once before processing rows
+  function getDepthLevel(benchmarkId, visited = new Set()) {
+    if (visited.has(benchmarkId)) return 0;
+    visited.add(benchmarkId);
+
+    const children = hierarchyMap.get(benchmarkId) || [];
+    if (children.length === 0) return 0;
+
+    const maxChildDepth = Math.max(...children.map(child => getDepthLevel(child, new Set(visited))));
+    return maxChildDepth + 1;
+  }
+
+  const allBenchmarkIds = Array.from(hierarchyMap.keys());
+  const benchmarksByDepth = allBenchmarkIds
+    .map(id => ({ id, depth: getDepthLevel(id) }))
+    .sort((a, b) => a.depth - b.depth);
+
+  // Determine which benchmarks should be excluded from aggregation
+  // Only exclude benchmarks that are hidden by wayback filtering (not benchmarks where all models failed)
+  const benchmarksToExcludeFromAggregation = new Set();
+  
+  // Check if wayback filtering is active
+  const minTimestamp = window.activeFilters?.min_wayback_timestamp;
+  const maxTimestamp = window.activeFilters?.max_wayback_timestamp;
+  const ranges = window.filterOptions?.datetime_range;
+  const fullRangeMin = ranges?.min_unix;
+  const fullRangeMax = ranges?.max_unix;
+  const isWaybackActive = minTimestamp && maxTimestamp && !(minTimestamp <= fullRangeMin && maxTimestamp >= fullRangeMax);
   
+  // Only exclude benchmarks hidden by wayback filtering
+  // When wayback filtering is NOT active, benchmarks with all "X" values should be treated as 0 (incomplete scores), not excluded
+  if (isWaybackActive && window.waybackHiddenBenchmarks) {
+    window.waybackHiddenBenchmarks.forEach(benchmarkId => {
+      benchmarksToExcludeFromAggregation.add(benchmarkId);
+    });
+  }
+
   // Then process each row for filtering
   workingRowData.forEach((row) => {
     const originalRow = window.originalRowData.find(origRow => origRow.id === row.id);
     if (!originalRow) return;
-    
-    function getDepthLevel(benchmarkId, visited = new Set()) {
-      if (visited.has(benchmarkId)) return 0;
-      visited.add(benchmarkId);
-      
-      const children = hierarchyMap.get(benchmarkId) || [];
-      if (children.length === 0) return 0;
-      
-      const maxChildDepth = Math.max(...children.map(child => getDepthLevel(child, new Set(visited))));
-      return maxChildDepth + 1;
-    }
-    
-    const allBenchmarkIds = Array.from(hierarchyMap.keys());
-    const benchmarksByDepth = allBenchmarkIds
-      .map(id => ({ id, depth: getDepthLevel(id) }))
-      .sort((a, b) => a.depth - b.depth);
-    
+
     benchmarksByDepth.forEach(({ id: benchmarkId }) => {
       const children = hierarchyMap.get(benchmarkId) || [];
-      
+
       if (children.length === 0) {
         if (excludedBenchmarks.has(benchmarkId)) {
           row[benchmarkId] = {
@@ -358,23 +709,29 @@ function updateFilteredScores(rowData) {
         }
       } else {
         const childScores = [];
-        
-        
+
         // First pass collect all children and determine if mixed valid/invalid scores
         const childInfo = [];
         children.forEach(childId => {
           if (!excludedBenchmarks.has(childId) && row[childId]) {
+            // Skip benchmarks that are hidden by wayback filtering
+            // These should be excluded entirely from aggregation, not treated as 0
+            // Benchmarks where all models failed (originally "X") should NOT be excluded - treat as 0
+            if (benchmarksToExcludeFromAggregation.has(childId)) {
+              return; // Exclude this benchmark entirely
+            }
+            
             const childScore = row[childId].value;
-            const hasValidScore = childScore !== null && childScore !== undefined && 
+            const hasValidScore = childScore !== null && childScore !== undefined &&
                                  childScore !== '' && childScore !== 'X' &&
                                  !isNaN(parseFloat(childScore));
             childInfo.push({ childId, childScore, hasValidScore });
           }
         });
-        
+
         // Check if any valid scores among the children
         const hasAnyValidScores = childInfo.some(info => info.hasValidScore);
-        
+
         // Second pass, build the scores array
         childInfo.forEach(({ childId, childScore, hasValidScore }) => {
           if (hasValidScore) {
@@ -383,15 +740,16 @@ function updateFilteredScores(rowData) {
             childScores.push(numVal);
           } else if (hasAnyValidScores && (childScore === 'X' || childScore === '')) {
             // If we have some valid scores, treat X/empty as 0
+            // (This handles cases where some models have valid scores but this model has X)
             childScores.push(0);
           }
           // If no valid scores exist at all, skip everything (childScores will be empty)
         });
-        
-        
+
+
         // Check if we should drop out this parent column
         let shouldDropOut = false;
-        
+
         if (childScores.length === 0) {
           // No children available at all
           shouldDropOut = true;
@@ -399,7 +757,7 @@ function updateFilteredScores(rowData) {
           // Check if all non-excluded children are X or 0
           let validChildrenCount = 0;
           let nonZeroChildrenCount = 0;
-          
+
           children.forEach(childId => {
             if (!excludedBenchmarks.has(childId) && row[childId]) {
               validChildrenCount++;
@@ -412,11 +770,11 @@ function updateFilteredScores(rowData) {
               }
             }
           });
-          
+
           // Drop out if no valid children or all valid children are 0/X
           shouldDropOut = validChildrenCount === 0 || nonZeroChildrenCount === 0;
         }
-        
+
         if (shouldDropOut) {
           row[benchmarkId] = {
             ...row[benchmarkId],
@@ -432,14 +790,15 @@ function updateFilteredScores(rowData) {
         }
       }
     });
-    
-    // Calculate global filtered score
+
+    // Calculate global filtered score AND update average_vision_v0
     const visionCategories = ['neural_vision_v0', 'behavior_vision_v0'];
     const categoryScores = [];
-    
+    let hasVisibleCategory = false;
+
     visionCategories.forEach(category => {
       const isExcluded = excludedBenchmarks.has(category);
-      
+
       // Check if this column would be visible (not dropped out)
       let isColumnVisible = true;
       if (window.getFilteredLeafCount && typeof window.getFilteredLeafCount === 'function') {
@@ -448,7 +807,12 @@ function updateFilteredScores(rowData) {
           isColumnVisible = false; // Column is dropped out
         }
       }
-      
+
+      // Track if at least one category is visible
+      if (!isExcluded && isColumnVisible && row[category]) {
+        hasVisibleCategory = true;
+      }
+
       // Only include in filtered score if column is visible and not excluded
       if (row[category] && !isExcluded && isColumnVisible) {
         const score = row[category].value;
@@ -468,28 +832,93 @@ function updateFilteredScores(rowData) {
         }
       }
     });
-    
-   
-    if (categoryScores.length > 0) {
-      const globalAverage = categoryScores.reduce((a, b) => a + b, 0) / categoryScores.length;
-      row._tempFilteredScore = globalAverage;
+
+    // Update average_vision_v0 (global score) to reflect the updated neural/behavior scores
+    // Only update if at least one category is visible. If neither is visible, leave it unchanged.
+    if (hasVisibleCategory) {
+      if (categoryScores.length > 0) {
+        // Check if both categories are X (both treated as 0, so average would be 0)
+        // If so, check if model has all 0/X scores - if yes, set to 'X' to filter it out
+        const neuralScore = row.neural_vision_v0?.value;
+        const behaviorScore = row.behavior_vision_v0?.value;
+        const bothAreX = (neuralScore === 'X' || neuralScore === null || neuralScore === undefined || neuralScore === '') &&
+                         (behaviorScore === 'X' || behaviorScore === null || behaviorScore === undefined || behaviorScore === '');
+        
+        if (bothAreX && categoryScores.length === 2 && categoryScores.every(s => s === 0)) {
+          // Both categories are X, check if model has all 0/X across all visible benchmarks
+          let hasAnyValidNonZeroScore = false;
+          allBenchmarkIds.forEach(benchmarkId => {
+            if (excludedBenchmarks.has(benchmarkId)) return;
+            if (benchmarksToExcludeFromAggregation.has(benchmarkId)) return;
+            if (!row[benchmarkId]) return;
+            
+            // Check if this benchmark is visible (not dropped out)
+            let isBenchmarkVisible = true;
+            if (window.getFilteredLeafCount && typeof window.getFilteredLeafCount === 'function') {
+              const leafCount = window.getFilteredLeafCount(benchmarkId);
+              if (leafCount === 0) {
+                isBenchmarkVisible = false;
+              }
+            }
+            if (!isBenchmarkVisible) return;
+            
+            const score = row[benchmarkId].value;
+            if (score !== null && score !== undefined && score !== '' && score !== 'X') {
+              const numVal = typeof score === 'string' ? parseFloat(score) : score;
+              if (!isNaN(numVal) && numVal !== 0) {
+                hasAnyValidNonZeroScore = true;
+              }
+            }
+          });
+
+          if (!hasAnyValidNonZeroScore) {
+            // Model has all 0/X scores, set to 'X' so it gets filtered out
+            row.average_vision_v0 = {
+              ...row.average_vision_v0,
+              value: 'X',
+              color: '#e0e1e2'
+            };
+            row._tempFilteredScore = null;
+            return; // Skip the rest of the loop iteration
+          }
+        }
+        
+        // Normal case: calculate average
+        const globalAverage = categoryScores.reduce((a, b) => a + b, 0) / categoryScores.length;
+        row.average_vision_v0 = {
+          ...row.average_vision_v0,
+          value: parseFloat(globalAverage.toFixed(3))
+        };
+        row._tempFilteredScore = globalAverage;
+      } else {
+        // categoryScores.length === 0 means both categories are excluded or not visible
+        // In this case, filtered_score should be 'X' because there are no valid scores
+        row._tempFilteredScore = null;
+        // Don't update average_vision_v0 - leave it as-is when both categories are excluded
+      }
     } else {
+      // Neither category is visible - filtered_score should be 'X'
       row._tempFilteredScore = null;
+      // Don't update average_vision_v0 - leave it as-is when neither category is visible
     }
+    // If neither category is visible, don't update average_vision_v0 (leave it as-is)
   });
 
   // Apply colors for recalculated benchmarks
-  const allBenchmarkIds = Array.from(hierarchyMap.keys());
+  // Reuse allBenchmarkIds that was already calculated above
   const recalculatedBenchmarks = new Set();
-  
+
+  // Always recalculate average_vision_v0 since we update it from neural/behavior scores
+  recalculatedBenchmarks.add('average_vision_v0');
+
   allBenchmarkIds.forEach(benchmarkId => {
     const children = hierarchyMap.get(benchmarkId) || [];
-    
+
     if (children.length > 0) {
       const hasExcludedChildren = children.some(childId => excludedBenchmarks.has(childId));
       if (hasExcludedChildren) {
         recalculatedBenchmarks.add(benchmarkId);
-        
+
         function markAncestorsRecalculated(targetId) {
           allBenchmarkIds.forEach(parentId => {
             const parentChildren = hierarchyMap.get(parentId) || [];
@@ -503,7 +932,7 @@ function updateFilteredScores(rowData) {
       }
     }
   });
-  
+
   // Apply blue coloring for recalculated benchmarks
   allBenchmarkIds.forEach(benchmarkId => {
     if (recalculatedBenchmarks.has(benchmarkId)) {
@@ -517,12 +946,12 @@ function updateFilteredScores(rowData) {
           }
         }
       });
-      
+
       if (scores.length > 0) {
         const minScore = Math.min(...scores);
         const maxScore = Math.max(...scores);
         const scoreRange = maxScore - minScore;
-        
+
         workingRowData.forEach(row => {
           if (row[benchmarkId] && row[benchmarkId].value !== 'X') {
             const val = row[benchmarkId].value;
@@ -533,7 +962,7 @@ function updateFilteredScores(rowData) {
               const green = Math.round(173 + (105 * (1 - intensity)));
               const red = Math.round(216 * (1 - intensity));
               const color = `rgba(${red}, ${green}, ${baseBlue}, 0.6)`;
-              
+
               row[benchmarkId].color = color;
             }
           }
@@ -557,7 +986,7 @@ function updateFilteredScores(rowData) {
   const globalFilteredScores = workingRowData
     .map(row => row._tempFilteredScore)
     .filter(score => score !== null);
-    
+
   const globalMinScore = globalFilteredScores.length > 0 ? Math.min(...globalFilteredScores) : 0;
   const globalMaxScore = globalFilteredScores.length > 0 ? Math.max(...globalFilteredScores) : 1;
   const globalScoreRange = globalMaxScore - globalMinScore;
@@ -614,7 +1043,7 @@ function toggleFilteredScoreColumn(gridApi) {
 
   const uncheckedCheckboxes = document.querySelectorAll('#benchmarkFilterPanel input[type="checkbox"]:not(:checked)');
   let hasNonEngineeringBenchmarkFilters = false;
-  
+
   // Only check for non-engineering benchmark filters if the benchmark panel is ready
   const benchmarkPanel = document.getElementById('benchmarkFilterPanel');
   if (benchmarkPanel && benchmarkPanel.children.length > 0) {
@@ -630,7 +1059,7 @@ function toggleFilteredScoreColumn(gridApi) {
   }
 
   const shouldShowFilteredScore = hasNonEngineeringBenchmarkFilters || hasBenchmarkMetadataFilters;
-  
+
 
   if (shouldShowFilteredScore) {
     // First, make column visible
@@ -640,7 +1069,7 @@ function toggleFilteredScoreColumn(gridApi) {
         { colId: 'average_vision_v0', hide: true }
       ]
     });
-    
+
     // Then apply sort with a small delay to ensure AG-Grid has processed the visibility change
     setTimeout(() => {
       // Try to simulate a manual click on the column header
@@ -652,7 +1081,7 @@ function toggleFilteredScoreColumn(gridApi) {
             { colId: 'filtered_score', sort: 'desc' }
           ]
         });
-        
+
         // Verify it worked, and if not, try to trigger sort via the column API
         setTimeout(() => {
           const currentSort = filteredScoreColumn.getSort();
@@ -670,8 +1099,38 @@ function toggleFilteredScoreColumn(gridApi) {
         { colId: 'average_vision_v0', hide: false }
       ]
     });
+
+    // Check if wayback filter is active - if so, sort by average_vision_v0 descending
+    const minTimestamp = window.activeFilters?.min_wayback_timestamp;
+    const maxTimestamp = window.activeFilters?.max_wayback_timestamp;
+    const ranges = window.filterOptions?.datetime_range;
+    const fullRangeMin = ranges?.min_unix;
+    const fullRangeMax = ranges?.max_unix;
+    const isWaybackActive = minTimestamp && maxTimestamp && !(minTimestamp <= fullRangeMin && maxTimestamp >= fullRangeMax);
+
+    if (isWaybackActive) {
+      // Sort by average_vision_v0 descending when wayback filter is active
+      setTimeout(() => {
+        const averageVisionColumn = gridApi.getAllGridColumns().find(col => col.getColId() === 'average_vision_v0');
+        if (averageVisionColumn) {
+          gridApi.applyColumnState({
+            state: [
+              { colId: 'average_vision_v0', sort: 'desc' }
+            ]
+          });
+
+          // Verify it worked, and if not, try to trigger sort via the column API
+          setTimeout(() => {
+            const currentSort = averageVisionColumn.getSort();
+            if (currentSort !== 'desc') {
+              averageVisionColumn.setSort('desc');
+            }
+          }, 50);
+        }
+      }, 25);
+    }
   }
-  
+
   // Ensure column visibility is updated after changing filtered score visibility
   setTimeout(() => {
     if (typeof window.LeaderboardHeaderComponents?.updateColumnVisibility === 'function') {
@@ -685,11 +1144,12 @@ window.LeaderboardFilterCoordinator = {
   applyCombinedFilters,
   resetAllFilters,
   updateFilteredScores,
-  toggleFilteredScoreColumn
+  toggleFilteredScoreColumn,
+  isColumnHiddenByWaybackFiltering
 };
 
 // Make main functions globally available for compatibility
 window.applyCombinedFilters = applyCombinedFilters;
 window.resetAllFilters = resetAllFilters;
 window.updateFilteredScores = updateFilteredScores;
-window.toggleFilteredScoreColumn = toggleFilteredScoreColumn;
\ No newline at end of file
+window.toggleFilteredScoreColumn = toggleFilteredScoreColumn;
diff --git a/static/benchmarks/js/leaderboard/filters/range-filters.js b/static/benchmarks/js/leaderboard/filters/range-filters.js
index 44b149eec..0ccea4335 100644
--- a/static/benchmarks/js/leaderboard/filters/range-filters.js
+++ b/static/benchmarks/js/leaderboard/filters/range-filters.js
@@ -1,5 +1,20 @@
 // Range slider functionality for numeric filters
 
+// ======================
+// CONFIGURATION
+// ======================
+// Set to true to freeze the min handle (start timestamp) for wayback timestamp slider
+// Set to false to allow both handles to be adjustable
+const FREEZE_WAYBACK_MIN_HANDLE = true;
+
+// Helper function to check if min handle should be frozen
+function shouldFreezeMinHandle(sliderType) {
+  return FREEZE_WAYBACK_MIN_HANDLE && sliderType === 'waybackTimestamp';
+}
+
+// Export for use in other modules
+window.shouldFreezeMinHandle = shouldFreezeMinHandle;
+
 // Initialize all dual-handle range sliders
 function initializeDualHandleSliders() {
   const sliderContainers = document.querySelectorAll('.slider-container');
@@ -13,43 +28,65 @@ function initializeDualHandleSlider(container) {
   const minHandle = container.querySelector('.handle-min');
   const maxHandle = container.querySelector('.handle-max');
   const range = container.querySelector('.slider-range');
-  
+
   if (!minHandle || !maxHandle || !range) return;
-  
+
   const min = parseFloat(container.dataset.min) || 0;
   const max = parseFloat(container.dataset.max) || 100;
-  
+
   let minValue = parseFloat(minHandle.dataset.value) || min;
   let maxValue = parseFloat(maxHandle.dataset.value) || max;
-  
+
   // Find associated input fields
   const sliderGroup = container.closest('.filter-group');
-  const sliderType = sliderGroup?.querySelector('#paramCountMin') ? 'paramCount' : 
-                     sliderGroup?.querySelector('#modelSizeMin') ? 'modelSize' : 
-                     sliderGroup?.querySelector('#stimuliCountMin') ? 'stimuliCount' : 'unknown';
-  
+  const sliderType = sliderGroup?.querySelector('#paramCountMin') ? 'paramCount' :
+                     sliderGroup?.querySelector('#modelSizeMin') ? 'modelSize' :
+                     sliderGroup?.querySelector('#stimuliCountMin') ? 'stimuliCount' :
+                     sliderGroup?.querySelector('#waybackDateMin') ? 'waybackTimestamp' : 'unknown';
+
   const minInput = sliderGroup?.querySelector('.range-input-min');
   const maxInput = sliderGroup?.querySelector('.range-input-max');
-  
+
   function updateSliderPosition() {
+    // For wayback timestamp, ensure minValue is always locked to minimum if frozen
+    if (shouldFreezeMinHandle(sliderType)) {
+      minValue = min;
+    }
+    
     const minPercent = ((minValue - min) / (max - min)) * 100;
     const maxPercent = ((maxValue - min) / (max - min)) * 100;
-    
+
     minHandle.style.left = `${minPercent}%`;
     maxHandle.style.left = `${maxPercent}%`;
-    
+
     range.style.left = `${minPercent}%`;
     range.style.width = `${maxPercent - minPercent}%`;
-    
+
     // Update input fields
     if (minInput) minInput.value = Math.round(minValue);
     if (maxInput) maxInput.value = Math.round(maxValue);
+
+    if (sliderType === 'waybackTimestamp') {
+      // Convert Unix timestamps to date strings for date inputs
+      if (minInput) {
+        const minDate = new Date(minValue * 1000);
+        minInput.value = minDate.toISOString().split('T')[0];
+      }
+      if (maxInput) {
+        const maxDate = new Date(maxValue * 1000);
+        maxInput.value = maxDate.toISOString().split('T')[0];
+      }
+    } else {
+      // Standard numeric inputs
+      if (minInput) minInput.value = Math.round(minValue);
+      if (maxInput) maxInput.value = Math.round(maxValue);
+    }
   }
-  
+
   function updateActiveFilters(skipDebounce = false) {
     const filterId = container.closest('.filter-group').id;
-    
-    if (filterId === 'paramCountMin' || filterId === 'paramCountMax' || 
+
+    if (filterId === 'paramCountMin' || filterId === 'paramCountMax' ||
         sliderGroup?.querySelector('#paramCountMin') || sliderGroup?.querySelector('#paramCountMax')) {
       const oldValue = window.activeFilters.max_param_count;
       window.activeFilters.max_param_count = maxValue < max ? maxValue : null;
@@ -73,86 +110,215 @@ function initializeDualHandleSlider(container) {
         newFilterValue: window.activeFilters.max_model_size,
         skipDebounce
       });
+    } else if (filterId === 'waybackTimestampFilter' || sliderType === 'waybackTimestamp') {
+      // For wayback timestamp, min is locked to minimum if frozen, otherwise use minValue
+      window.activeFilters.min_wayback_timestamp = shouldFreezeMinHandle(sliderType) ? min : minValue;
+      window.activeFilters.max_wayback_timestamp = maxValue;
+      console.log(`🎚️ ${sliderType} filter update:`, {
+        minValue: min, // Always minimum (frozen)
+        maxValue,
+        min: min,
+        max: max,
+        isAtFullRange: (minValue <= min && maxValue >= max),
+        skipDebounce
+      });
     }
-    
+
     // Apply filters with debouncing - but not during initial setup
     if (!skipDebounce) {
       console.log(`🎚️ ${sliderType} triggering debounceFilterUpdate`);
-      
+
       // If this is the stimuli count slider, also update benchmark filters
       if (sliderType === 'stimuliCount') {
         if (typeof window.LeaderboardBenchmarkFilters?.updateBenchmarkFilters === 'function') {
           window.LeaderboardBenchmarkFilters.updateBenchmarkFilters();
         }
       }
-      
+
       debounceFilterUpdate();
     }
   }
-  
+
   function handleMouseMove(e, handle, isMin) {
+    // Prevent min handle movement if frozen
+    if (shouldFreezeMinHandle(sliderType) && isMin) {
+      return;
+    }
+
     const rect = container.getBoundingClientRect();
     const percent = Math.max(0, Math.min(1, (e.clientX - rect.left) / rect.width));
     const value = min + percent * (max - min);
-    
+
     if (isMin) {
       minValue = Math.min(value, maxValue - 1);
     } else {
       maxValue = Math.max(value, minValue + 1);
     }
-    
+
     updateSliderPosition();
     updateActiveFilters();
   }
-  
+
   function addMouseListeners(handle, isMin) {
+    // Skip adding listeners for disabled min handle if frozen
+    if (shouldFreezeMinHandle(sliderType) && isMin) {
+      return;
+    }
+
     let isDragging = false;
-    
+    let tooltip = null;
+
     handle.addEventListener('mousedown', (e) => {
       isDragging = true;
       document.addEventListener('mousemove', mouseMoveHandler);
       document.addEventListener('mouseup', mouseUpHandler);
       e.preventDefault();
+      
+      // Create tooltip for wayback timestamp slider (only for max handle if min is frozen)
+      if (sliderType === 'waybackTimestamp' && typeof createTooltip === 'function' && (!shouldFreezeMinHandle(sliderType) || !isMin)) {
+        const currentValue = isMin ? minValue : maxValue;
+        const date = new Date(currentValue * 1000);
+        const dateStr = date.toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' });
+        tooltip = createTooltip(handle, dateStr, {
+          type: 'info',
+          position: 'top',
+          duration: 999999, // Don't auto-hide while dragging
+          offset: 25
+        });
+      }
     });
-    
+
     function mouseMoveHandler(e) {
       if (isDragging) {
         handleMouseMove(e, handle, isMin);
+        
+        // Update tooltip for wayback timestamp slider (only for max handle if min is frozen)
+        if (sliderType === 'waybackTimestamp' && tooltip && typeof createTooltip === 'function' && (!shouldFreezeMinHandle(sliderType) || !isMin)) {
+          const currentValue = isMin ? minValue : maxValue;
+          const date = new Date(currentValue * 1000);
+          const dateStr = date.toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' });
+          
+          // Update tooltip content and position
+          tooltip.remove();
+          tooltip = createTooltip(handle, dateStr, {
+            type: 'info',
+            position: 'top',
+            duration: 999999,
+            offset: 25
+          });
+        }
       }
     }
-    
+
     function mouseUpHandler() {
       isDragging = false;
       document.removeEventListener('mousemove', mouseMoveHandler);
       document.removeEventListener('mouseup', mouseUpHandler);
+      
+      // Remove tooltip when dragging ends
+      if (tooltip) {
+        tooltip.remove();
+        tooltip = null;
+      }
     }
   }
-  
+
   addMouseListeners(minHandle, true);
   addMouseListeners(maxHandle, false);
-  
+
   // Input field synchronization
   if (minInput) {
-    minInput.addEventListener('input', () => {
-      const value = parseFloat(minInput.value) || min;
-      minValue = Math.max(min, Math.min(value, maxValue - 1));
-      updateSliderPosition();
-      updateActiveFilters();
-    });
+    // Skip event listener for wayback timestamp min input if frozen
+    if (!shouldFreezeMinHandle(sliderType)) {
+      minInput?.addEventListener('change', () => {
+        if (sliderType === 'waybackTimestamp') {
+          const ts = new Date(minInput.value).getTime() / 1000;
+          if (!isNaN(ts)) {
+            minValue = ts;
+            minHandle.dataset.value = ts;
+            updateSliderPosition();
+            updateActiveFilters();
+          }
+        } else {
+          const ts = parseFloat(minInput.value);
+          if (!isNaN(ts)) {
+            minValue = ts;
+            minHandle.dataset.value = ts;
+            updateSliderPosition();
+            updateActiveFilters();
+          }
+        }
+      });
+    }
   }
-  
+
   if (maxInput) {
-    maxInput.addEventListener('input', () => {
-      const value = parseFloat(maxInput.value) || max;
-      maxValue = Math.min(max, Math.max(value, minValue + 1));
+    maxInput?.addEventListener('change', () => {
+    const ts = new Date(maxInput.value).getTime() / 1000;
+    if (!isNaN(ts)) {
+      // For wayback timestamp, ensure value doesn't exceed today's date
+      if (sliderType === 'waybackTimestamp') {
+        const today = new Date();
+        today.setHours(23, 59, 59, 999); // End of today
+        const todayTs = Math.floor(today.getTime() / 1000);
+        if (ts > todayTs) {
+          // Clamp to today's date
+          maxInput.value = today.toISOString().split('T')[0];
+          maxValue = todayTs;
+        } else {
+          maxValue = ts;
+        }
+      } else {
+        maxValue = ts;
+      }
+      maxHandle.dataset.value = maxValue;
       updateSliderPosition();
       updateActiveFilters();
+    }
     });
   }
-  
+
+  // For minInput
+  if (sliderType === 'waybackTimestamp') {
+    // For wayback timestamp, lock min value to minimum if frozen
+    if (shouldFreezeMinHandle(sliderType)) {
+      minValue = min; // Always use the minimum timestamp
+      minHandle.dataset.value = minValue;
+      // Disable min input and handle for wayback timestamp
+      if (minInput) {
+        minInput.disabled = true;
+        minInput.style.cursor = 'not-allowed';
+        minInput.style.opacity = '0.6';
+      }
+      // Disable min handle dragging
+      minHandle.style.cursor = 'not-allowed';
+      minHandle.style.opacity = '0.6';
+      minHandle.classList.add('handle-disabled');
+    } else {
+      // If not frozen, initialize normally
+      const dateValue = new Date(minInput.value);
+      minValue = isNaN(dateValue.getTime()) ? min : Math.floor(dateValue.getTime() / 1000);
+      minHandle.dataset.value = minValue;
+    }
+  } else {
+    minValue = parseFloat(minInput.value) || min;
+    minHandle.dataset.value = minValue;
+  }
+
+  // For maxInput
+  if (sliderType === 'waybackTimestamp') {
+    // Convert date string to Unix timestamp
+    const dateValue = new Date(maxInput.value);
+    maxValue = isNaN(dateValue.getTime()) ? max : Math.floor(dateValue.getTime() / 1000);
+    maxHandle.dataset.value = maxValue;
+  } else {
+    maxValue = parseFloat(maxInput.value) || max;
+    maxHandle.dataset.value = maxValue;
+  }
+
   // Initial position - don't trigger filters during setup
   updateSliderPosition();
-  
+
   // Update active filters without debouncing during initial setup
   updateActiveFilters(true);
 }
@@ -172,19 +338,21 @@ function debounceFilterUpdate() {
 function resetSliderUI() {
   const ranges = window.filterOptions || {};
   const sliderContainers = document.querySelectorAll('.slider-container');
-  
+
   sliderContainers.forEach(container => {
     const minHandle = container.querySelector('.handle-min');
     const maxHandle = container.querySelector('.handle-max');
     const range = container.querySelector('.slider-range');
-    
+
     if (!minHandle || !maxHandle || !range) return;
-    
+
     const min = parseFloat(container.dataset.min) || 0;
     let max = parseFloat(container.dataset.max) || 100;
-    
+
     // Use correct max values from filterOptions
     const sliderGroup = container.closest('.filter-group');
+    const isWaybackTimestamp = sliderGroup?.querySelector('#waybackDateMin');
+    
     if (sliderGroup?.querySelector('#paramCountMin') && ranges.parameter_ranges?.max) {
       max = ranges.parameter_ranges.max;
       container.dataset.max = max;
@@ -194,24 +362,62 @@ function resetSliderUI() {
     } else if (sliderGroup?.querySelector('#stimuliCountMin') && ranges.stimuli_ranges?.max) {
       max = ranges.stimuli_ranges.max;
       container.dataset.max = max;
+    } else if (isWaybackTimestamp && ranges.datetime_range?.min_unix && ranges.datetime_range?.max_unix) {
+      min = ranges.datetime_range.min_unix;
+      max = ranges.datetime_range.max_unix;
+      container.dataset.min = min;
+      container.dataset.max = max;
+      // Lock min value for wayback timestamp if frozen
+      if (shouldFreezeMinHandle('waybackTimestamp')) {
+        const minHandle = container.querySelector('.handle-min');
+        const minInput = sliderGroup?.querySelector('.range-input-min');
+        if (minHandle) {
+          minHandle.dataset.value = min;
+          minHandle.style.left = '0%';
+          minHandle.style.cursor = 'not-allowed';
+          minHandle.style.opacity = '0.6';
+          minHandle.classList.add('handle-disabled');
+        }
+        if (minInput) {
+          minInput.disabled = true;
+          minInput.style.cursor = 'not-allowed';
+          minInput.style.opacity = '0.6';
+        }
+      }
     }
-    
+
     // Reset to full range
     minHandle.style.left = '0%';
     maxHandle.style.left = '100%';
     range.style.left = '0%';
     range.style.width = '100%';
-    
+
     // Update data attributes
     minHandle.dataset.value = min;
     maxHandle.dataset.value = max;
-    
+
     // Update input fields
     const minInput = sliderGroup?.querySelector('.range-input-min');
     const maxInput = sliderGroup?.querySelector('.range-input-max');
-    
-    if (minInput) minInput.value = min;
-    if (maxInput) maxInput.value = max;
+
+    if (isWaybackTimestamp) {
+      // For wayback timestamp, convert Unix timestamps to ISO date strings
+      const minDate = new Date(min * 1000);
+      const maxDate = new Date(max * 1000);
+      if (minInput) minInput.value = minDate.toISOString().split('T')[0];
+      if (maxInput) {
+        // Ensure max doesn't exceed today's date
+        const today = new Date();
+        const todayStr = today.toISOString().split('T')[0];
+        const maxDateStr = maxDate.toISOString().split('T')[0];
+        maxInput.value = maxDateStr > todayStr ? todayStr : maxDateStr;
+        maxInput.max = todayStr;
+      }
+    } else {
+      // Standard numeric inputs
+      if (minInput) minInput.value = min;
+      if (maxInput) maxInput.value = max;
+    }
   });
 }
 
@@ -219,12 +425,12 @@ function resetSliderUI() {
 function getRangeValues(filterId) {
   const container = document.querySelector(`#${filterId}`)?.closest('.filter-group')?.querySelector('.slider-container');
   if (!container) return null;
-  
+
   const minHandle = container.querySelector('.handle-min');
   const maxHandle = container.querySelector('.handle-max');
-  
+
   if (!minHandle || !maxHandle) return null;
-  
+
   return {
     min: parseFloat(minHandle.dataset.value) || 0,
     max: parseFloat(maxHandle.dataset.value) || 100
@@ -235,37 +441,76 @@ function getRangeValues(filterId) {
 function setRangeValues(filterId, minVal, maxVal) {
   const container = document.querySelector(`#${filterId}`)?.closest('.filter-group')?.querySelector('.slider-container');
   if (!container) return;
-  
+
   const minHandle = container.querySelector('.handle-min');
   const maxHandle = container.querySelector('.handle-max');
   const range = container.querySelector('.slider-range');
-  
+
   if (!minHandle || !maxHandle || !range) return;
-  
+
   const min = parseFloat(container.dataset.min) || 0;
   const max = parseFloat(container.dataset.max) || 100;
-  
-  const minValue = Math.max(min, Math.min(minVal, max));
-  const maxValue = Math.max(min, Math.min(maxVal, max));
-  
+
+  // Check if this is wayback timestamp slider
+  const sliderGroup = container.closest('.filter-group');
+  const isWaybackTimestamp = sliderGroup?.querySelector('#waybackDateMin');
+
+  // For wayback timestamp, handle frozen min handle
+  let minValue, maxValue;
+  if (isWaybackTimestamp && typeof window.shouldFreezeMinHandle === 'function' && window.shouldFreezeMinHandle('waybackTimestamp')) {
+    // Min is always locked to minimum
+    minValue = min;
+    maxValue = Math.max(min, Math.min(maxVal, max));
+  } else {
+    minValue = Math.max(min, Math.min(minVal, max));
+    maxValue = Math.max(min, Math.min(maxVal, max));
+  }
+
   minHandle.dataset.value = minValue;
   maxHandle.dataset.value = maxValue;
-  
+
   const minPercent = ((minValue - min) / (max - min)) * 100;
   const maxPercent = ((maxValue - min) / (max - min)) * 100;
-  
+
   minHandle.style.left = `${minPercent}%`;
   maxHandle.style.left = `${maxPercent}%`;
   range.style.left = `${minPercent}%`;
   range.style.width = `${maxPercent - minPercent}%`;
-  
+
   // Update input fields
-  const sliderGroup = container.closest('.filter-group');
   const minInput = sliderGroup?.querySelector('.range-input-min');
   const maxInput = sliderGroup?.querySelector('.range-input-max');
-  
-  if (minInput) minInput.value = Math.round(minValue);
-  if (maxInput) maxInput.value = Math.round(maxValue);
+
+  if (isWaybackTimestamp) {
+    // For wayback timestamp, convert Unix timestamps to date strings
+    if (minInput) {
+      const minDate = new Date(minValue * 1000);
+      minInput.value = minDate.toISOString().split('T')[0];
+    }
+    if (maxInput) {
+      const maxDate = new Date(maxValue * 1000);
+      // Ensure max doesn't exceed today's date
+      const today = new Date();
+      const todayStr = today.toISOString().split('T')[0];
+      const maxDateStr = maxDate.toISOString().split('T')[0];
+      maxInput.value = maxDateStr > todayStr ? todayStr : maxDateStr;
+      maxInput.max = todayStr;
+      // Update maxValue if clamped
+      if (maxDateStr > todayStr) {
+        const todayTs = Math.floor(today.getTime() / 1000);
+        maxValue = Math.min(maxValue, todayTs);
+        maxHandle.dataset.value = maxValue;
+        // Recalculate position if value changed
+        const newMaxPercent = ((maxValue - min) / (max - min)) * 100;
+        maxHandle.style.left = `${newMaxPercent}%`;
+        range.style.width = `${newMaxPercent - minPercent}%`;
+      }
+    }
+  } else {
+    // Standard numeric inputs
+    if (minInput) minInput.value = Math.round(minValue);
+    if (maxInput) maxInput.value = Math.round(maxValue);
+  }
 }
 
 // Export functions for use by other modules
@@ -276,4 +521,4 @@ window.LeaderboardRangeFilters = {
   getRangeValues,
   setRangeValues,
   debounceFilterUpdate
-};
\ No newline at end of file
+};
diff --git a/static/benchmarks/js/leaderboard/navigation/url-state.js b/static/benchmarks/js/leaderboard/navigation/url-state.js
index 5885cfbbd..c7cf94555 100644
--- a/static/benchmarks/js/leaderboard/navigation/url-state.js
+++ b/static/benchmarks/js/leaderboard/navigation/url-state.js
@@ -3,13 +3,13 @@
 // Parse URL parameters and apply filters
 function parseURLFilters() {
   const urlParams = new URLSearchParams(window.location.search);
-  
+
   // Parse multi-select filters
   const parseList = (param) => {
     const value = urlParams.get(param);
     return value ? value.split(',').map(v => v.trim()) : [];
   };
-  
+
   window.activeFilters.architecture = parseList('architecture');
   window.activeFilters.model_family = parseList('model_family');
   window.activeFilters.training_dataset = parseList('training_dataset');
@@ -17,17 +17,17 @@ function parseURLFilters() {
   window.activeFilters.benchmark_regions = parseList('benchmark_regions');
   window.activeFilters.benchmark_species = parseList('benchmark_species');
   window.activeFilters.benchmark_tasks = parseList('benchmark_tasks');
-  
+
   // Parse boolean filters
   window.activeFilters.public_data_only = urlParams.get('public_data_only') === 'true';
   window.activeFilters.runnable_only = urlParams.get('runnable_only') === 'true';
-  
+
   // Parse range filters
   const parseFloatParam = (param) => {
     const value = urlParams.get(param);
     return value ? parseFloat(value) : null;
   };
-  
+
   window.activeFilters.min_param_count = parseFloatParam('min_param_count');
   window.activeFilters.max_param_count = parseFloatParam('max_param_count');
   window.activeFilters.min_model_size = parseFloatParam('min_model_size');
@@ -36,19 +36,26 @@ function parseURLFilters() {
   window.activeFilters.max_score = parseFloatParam('max_score');
   window.activeFilters.min_stimuli_count = parseFloatParam('min_stimuli_count');
   window.activeFilters.max_stimuli_count = parseFloatParam('max_stimuli_count');
-  
+  const defaultMin = window.filterOptions?.datetime_range?.min_unix;
+  const defaultMax = window.filterOptions?.datetime_range?.max_unix ?? Math.floor(Date.now() / 1000);
+
+  window.activeFilters.min_wayback_timestamp =
+    parseFloatParam('min_wayback_timestamp') ?? defaultMin;
+  window.activeFilters.max_wayback_timestamp =
+    parseFloatParam('max_wayback_timestamp') ?? defaultMax;
+
   // Apply filters to UI
   applyFiltersToUI();
-  
+
   // Parse benchmark exclusions
   const excludedBenchmarks = urlParams.get('excluded_benchmarks');
   if (excludedBenchmarks) {
     window.filteredOutBenchmarks = new Set(decodeBenchmarkFilters(excludedBenchmarks));
   }
-  
+
   // Update benchmark tree checkboxes
   updateBenchmarkTreeFromURL();
-  
+
   // Apply all filters
   if (typeof window.applyCombinedFilters === 'function') {
     window.applyCombinedFilters();
@@ -62,18 +69,18 @@ function applyFiltersToUI() {
   updateDropdownInput('modelFamilyFilter', window.activeFilters.model_family);
   updateDropdownInput('trainingDatasetFilter', window.activeFilters.training_dataset);
   updateDropdownInput('taskSpecFilter', window.activeFilters.task_specialization);
-  
+
   // Update checkboxes
   updateCheckboxes('.region-checkbox', window.activeFilters.benchmark_regions);
   updateCheckboxes('.species-checkbox', window.activeFilters.benchmark_species);
   updateCheckboxes('.task-checkbox', window.activeFilters.benchmark_tasks);
-  
+
   // Update boolean checkboxes
   const publicDataCheckbox = document.getElementById('publicDataFilter');
   if (publicDataCheckbox) {
     publicDataCheckbox.checked = window.activeFilters.public_data_only;
   }
-  
+
   // Update range inputs
   updateRangeInput('paramCountMin', window.activeFilters.min_param_count);
   updateRangeInput('paramCountMax', window.activeFilters.max_param_count);
@@ -81,7 +88,7 @@ function applyFiltersToUI() {
   updateRangeInput('modelSizeMax', window.activeFilters.max_model_size);
   updateRangeInput('stimuliCountMin', window.activeFilters.min_stimuli_count);
   updateRangeInput('stimuliCountMax', window.activeFilters.max_stimuli_count);
-  
+
   // Update range sliders
   if (typeof window.LeaderboardRangeFilters?.setRangeValues === 'function') {
     if (window.activeFilters.min_param_count !== null || window.activeFilters.max_param_count !== null) {
@@ -89,18 +96,55 @@ function applyFiltersToUI() {
       const max = window.activeFilters.max_param_count || 100;
       window.LeaderboardRangeFilters.setRangeValues('paramCountMin', min, max);
     }
-    
+
     if (window.activeFilters.min_model_size !== null || window.activeFilters.max_model_size !== null) {
       const min = window.activeFilters.min_model_size || 0;
       const max = window.activeFilters.max_model_size || 1000;
       window.LeaderboardRangeFilters.setRangeValues('modelSizeMin', min, max);
     }
-    
+
     if (window.activeFilters.min_stimuli_count !== null || window.activeFilters.max_stimuli_count !== null) {
       const min = window.activeFilters.min_stimuli_count || 0;
       const max = window.activeFilters.max_stimuli_count || 1000;
       window.LeaderboardRangeFilters.setRangeValues('stimuliCountMin', min, max);
     }
+
+    if (window.activeFilters.min_wayback_timestamp !== null || window.activeFilters.max_wayback_timestamp !== null) {
+      // Update slider handles and date inputs using setRangeValues
+      if (typeof window.LeaderboardRangeFilters?.setRangeValues === 'function') {
+        const ranges = window.filterOptions?.datetime_range;
+        const defaultMin = ranges?.min_unix || 0;
+        const defaultMax = ranges?.max_unix || Math.floor(Date.now() / 1000);
+        
+        const minTimestamp = window.activeFilters.min_wayback_timestamp ?? defaultMin;
+        const maxTimestamp = window.activeFilters.max_wayback_timestamp ?? defaultMax;
+        
+        window.LeaderboardRangeFilters.setRangeValues('waybackTimestampFilter', minTimestamp, maxTimestamp);
+      } else {
+        // Fallback: Update date inputs only (if setRangeValues not available)
+        const waybackDateMin = document.getElementById('waybackDateMin');
+        const waybackDateMax = document.getElementById('waybackDateMax');
+
+        if (waybackDateMin && window.activeFilters.min_wayback_timestamp) {
+          const minDate = new Date(window.activeFilters.min_wayback_timestamp * 1000);
+          waybackDateMin.value = minDate.toISOString().split('T')[0];
+        }
+
+        if (waybackDateMax && window.activeFilters.max_wayback_timestamp) {
+          const maxDate = new Date(window.activeFilters.max_wayback_timestamp * 1000);
+          // Ensure max doesn't exceed today's date
+          const today = new Date();
+          const todayStr = today.toISOString().split('T')[0];
+          const maxDateStr = maxDate.toISOString().split('T')[0];
+          waybackDateMax.value = maxDateStr > todayStr ? todayStr : maxDateStr;
+          waybackDateMax.max = todayStr;
+        } else if (waybackDateMax) {
+          // Set max attribute even if no value is set from URL
+          const today = new Date();
+          waybackDateMax.max = today.toISOString().split('T')[0];
+        }
+      }
+    }
   }
 }
 
@@ -108,7 +152,7 @@ function applyFiltersToUI() {
 function updateDropdownInput(filterId, selectedValues) {
   const filter = document.getElementById(filterId);
   if (!filter || !selectedValues || selectedValues.length === 0) return;
-  
+
   const input = filter.querySelector('.filter-input');
   if (input) {
     input.value = selectedValues.join(', ');
@@ -134,7 +178,7 @@ function updateRangeInput(inputId, value) {
 // Update benchmark tree checkboxes based on URL exclusions
 function updateBenchmarkTreeFromURL() {
   const allCheckboxes = document.querySelectorAll('#benchmarkFilterPanel input[type="checkbox"]');
-  
+
   allCheckboxes.forEach(checkbox => {
     if (window.filteredOutBenchmarks && window.filteredOutBenchmarks.has(checkbox.value)) {
       checkbox.checked = false;
@@ -147,7 +191,7 @@ function updateBenchmarkTreeFromURL() {
 // Update URL with current filter state
 function updateURLFromFilters() {
   const params = new URLSearchParams();
-  
+
   // Add list parameters
   const addList = (key, urlParam) => {
     const param = urlParam || key;
@@ -155,7 +199,7 @@ function updateURLFromFilters() {
       params.set(param, window.activeFilters[key].join(','));
     }
   };
-  
+
   addList('architecture');
   addList('model_family');
   addList('training_dataset');
@@ -163,23 +207,23 @@ function updateURLFromFilters() {
   addList('benchmark_regions');
   addList('benchmark_species');
   addList('benchmark_tasks');
-  
+
   // Add boolean parameters
   if (window.activeFilters.public_data_only) {
     params.set('public_data_only', 'true');
   }
-  
+
   if (window.activeFilters.runnable_only) {
     params.set('runnable_only', 'true');
   }
-  
+
   // Add range parameters
   const addRange = (key) => {
     if (window.activeFilters[key] !== null && window.activeFilters[key] !== undefined) {
       params.set(key, window.activeFilters[key].toString());
     }
   };
-  
+
   addRange('min_param_count');
   addRange('max_param_count');
   addRange('min_model_size');
@@ -188,13 +232,15 @@ function updateURLFromFilters() {
   addRange('max_score');
   addRange('min_stimuli_count');
   addRange('max_stimuli_count');
-  
+  addRange('min_wayback_timestamp');
+  addRange('max_wayback_timestamp');
+
   // Add benchmark exclusions
   const excludedBenchmarks = encodeBenchmarkFilters();
   if (excludedBenchmarks) {
     params.set('excluded_benchmarks', excludedBenchmarks);
   }
-  
+
   // Update URL without page reload
   const newURL = `${window.location.pathname}?${params.toString()}`;
   window.history.replaceState({}, '', newURL);
@@ -205,14 +251,14 @@ function encodeBenchmarkFilters() {
   if (!window.filteredOutBenchmarks || window.filteredOutBenchmarks.size === 0) {
     return null;
   }
-  
+
   return Array.from(window.filteredOutBenchmarks).join(',');
 }
 
 // Decode benchmark filters from URL
 function decodeBenchmarkFilters(encodedFilters) {
   if (!encodedFilters) return [];
-  
+
   return encodedFilters.split(',').map(id => id.trim()).filter(id => id);
 }
 
@@ -226,11 +272,11 @@ function clearURLParameters() {
 function getCurrentURLParams() {
   const params = new URLSearchParams(window.location.search);
   const result = {};
-  
+
   for (const [key, value] of params.entries()) {
     result[key] = value;
   }
-  
+
   return result;
 }
 
@@ -244,7 +290,7 @@ function hasURLFilters() {
     'min_param_count', 'max_param_count', 'min_model_size', 'max_model_size',
     'min_score', 'max_score', 'min_stimuli_count', 'max_stimuli_count'
   ];
-  
+
   return filterParams.some(param => params.has(param));
 }
 
@@ -258,4 +304,4 @@ window.LeaderboardURLState = {
   clearURLParameters,
   getCurrentURLParams,
   hasURLFilters
-};
\ No newline at end of file
+};
diff --git a/static/benchmarks/js/leaderboard/renderers/header-components.js b/static/benchmarks/js/leaderboard/renderers/header-components.js
index a97717aa3..2c5bbcbd3 100644
--- a/static/benchmarks/js/leaderboard/renderers/header-components.js
+++ b/static/benchmarks/js/leaderboard/renderers/header-components.js
@@ -4,8 +4,8 @@
 function buildHierarchyFromTree(tree, hierarchyMap = new Map()) {
   tree.forEach(node => {
     const nodeId = node.id || node.identifier || node.field || node.name;
-    const children = node.children ? 
-      node.children.map(child => child.id || child.identifier || child.field || child.name).filter(Boolean) : 
+    const children = node.children ?
+      node.children.map(child => child.id || child.identifier || child.field || child.name).filter(Boolean) :
       [];
     if (nodeId) {
       hierarchyMap.set(nodeId, children);
@@ -35,13 +35,13 @@ function createSortIndicator(params, element, fontSize = '12px') {
   indicator.style.marginLeft = '4px';
   indicator.style.fontSize = '16px';
   indicator.style.opacity = '0.87';
-  
+
   const updateSortIndicator = () => {
     const column = params.column;
     const currentSort = column.getSort();
-    
+
     indicator.classList.remove('ag-icon-asc', 'ag-icon-desc', 'ag-icon-none');
-    
+
     if (currentSort === 'asc') {
       indicator.classList.add('ag-icon-asc');
       indicator.style.opacity = '1';
@@ -56,7 +56,7 @@ function createSortIndicator(params, element, fontSize = '12px') {
 
   const handleSort = (event) => {
     event.stopPropagation();
-    
+
     const column = params.column;
     const colId = column.getColId();
     const currentSort = column.getSort();
@@ -68,7 +68,7 @@ function createSortIndicator(params, element, fontSize = '12px') {
         defaultState: { sort: null }
       });
     }
-    
+
     setTimeout(updateSortIndicator, 10);
   };
 
@@ -86,14 +86,14 @@ function createSortIndicator(params, element, fontSize = '12px') {
 // Update column visibility based on filtering state
 function updateColumnVisibility() {
   if (!window.globalGridApi || !window.benchmarkTree) return;
-  
+
   const hierarchyMap = buildHierarchyFromTree(window.benchmarkTree);
   const excludedBenchmarks = new Set(window.filteredOutBenchmarks || []);
-  
+
   // Get all columns
   const allColumns = window.globalGridApi.getAllGridColumns();
   const columnsToUpdate = [];
-  
+
   // Determine which columns should be visible based on:
   // 1. Current filter state (excluded benchmarks)
   // 2. Current expansion state (what the user has expanded)
@@ -102,7 +102,7 @@ function updateColumnVisibility() {
     if (excludedBenchmarks.has(benchmarkId)) {
       return false;
     }
-    
+
     // Check if this is the global score column and filtered score is active
     if (benchmarkId === 'average_vision_v0') {
       // Hide global score when filtered score is visible
@@ -112,7 +112,7 @@ function updateColumnVisibility() {
       }
       return true; // Show global score when filtered score is not active
     }
-    
+
     // Check if this is a top-level category
     const domain = (window.DJANGO_DATA && window.DJANGO_DATA.domain) || 'vision';
     const topLevelCategories = [`neural_${domain}_v0`, `behavior_${domain}_v0`, `engineering_${domain}_v0`];
@@ -126,7 +126,7 @@ function updateColumnVisibility() {
       }
       return true;
     }
-    
+
     // Determine if this is a leaf column or parent column (use cached hierarchy)
     if (!window.cachedHierarchyMap) {
       window.cachedHierarchyMap = buildHierarchyFromTree(window.benchmarkTree || []);
@@ -134,7 +134,7 @@ function updateColumnVisibility() {
     const hierarchyMap = window.cachedHierarchyMap;
     const children = hierarchyMap.get(benchmarkId) || [];
     const isLeafColumn = children.length === 0;
-    
+
     if (isLeafColumn) {
       // For leaf columns: hide if all values are X's or 0's
       if (shouldHideColumnWithAllXsOrZeros(benchmarkId)) {
@@ -148,8 +148,13 @@ function updateColumnVisibility() {
           return false;
         }
       }
+
+      // For wayback filtering, also hide parent columns if all their values are 'X'
+      if (shouldHideColumnWithAllXsOrZeros(benchmarkId)) {
+        return false;
+      }
     }
-    
+
     // For non-top-level benchmarks, check expansion state
     // Find the parent of this benchmark
     let parentId = null;
@@ -159,19 +164,19 @@ function updateColumnVisibility() {
         break;
       }
     }
-    
+
     if (!parentId) {
       // No parent found, treat as top-level
       return true;
     }
-    
+
     // Parent must be expanded and visible for this to be visible
     const isParentExpanded = window.columnExpansionState.get(parentId) === true;
     const isParentVisible = shouldColumnBeVisible(parentId);
-    
+
     return isParentExpanded && isParentVisible;
   }
-  
+
   function shouldHideColumnWithAllXsOrZeros(benchmarkId) {
     // Get current row data (filtered data)
     const rowData = [];
@@ -182,44 +187,64 @@ function updateColumnVisibility() {
         }
       });
     }
-    
+
     if (rowData.length === 0) {
       return false;
     }
-    
+
     // Check if all values in this column are X or 0
     const values = rowData.map(row => {
       const cellData = row[benchmarkId];
       return cellData && typeof cellData === 'object' ? cellData.value : cellData;
     }).filter(val => val !== null && val !== undefined && val !== '');
-    
+
     if (values.length === 0) {
       return false; // Don't hide if no values
     }
-    
-    // Check if all values are 'X' or 0
-    const allXsOrZeros = values.every(val => val === 'X' || val === 0);
-    
-    
-    return allXsOrZeros;
+
+    // Check if wayback timestamp filtering is active
+    const minTimestamp = window.activeFilters?.min_wayback_timestamp;
+    const maxTimestamp = window.activeFilters?.max_wayback_timestamp;
+    const ranges = window.filterOptions?.datetime_range;
+    const fullRangeMin = ranges?.min_unix;
+    const fullRangeMax = ranges?.max_unix;
+    const isWaybackActive = minTimestamp && maxTimestamp && !(minTimestamp <= fullRangeMin && maxTimestamp >= fullRangeMax);
+
+    if (isWaybackActive) {
+      // For wayback filtering: hide only if this benchmark is in waybackHiddenBenchmarks
+      // This ensures we only hide columns where wayback filtering set all values to X,
+      // not columns where all models failed (originally X values)
+      if (window.waybackHiddenBenchmarks && window.waybackHiddenBenchmarks.has(benchmarkId)) {
+        return true;
+      }
+      // If not in waybackHiddenBenchmarks, don't hide (even if all values are X from model failures)
+      return false;
+    }
+
+    // When wayback filtering is NOT active:
+    // Don't hide columns based on "X" values alone - these are model failures, not invalid benchmarks
+    // Only hide if all values are 0 (which indicates an invalid/empty benchmark)
+    // This ensures model property filters don't incorrectly hide columns when all filtered models failed
+    const allZeros = values.every(val => val === 0);
+    return allZeros;
   }
-  
+
   allColumns.forEach(column => {
     const colId = column.getColId();
-    
+
     // Skip non-benchmark columns (including runnable status)
     if (['model', 'rank', 'runnable_status', 'filtered_score'].includes(colId)) {
       return;
     }
-    
+
     const shouldShow = shouldColumnBeVisible(colId);
     const isCurrentlyVisible = column.isVisible();
-    
+
     if (shouldShow !== isCurrentlyVisible) {
       columnsToUpdate.push({ colId, hide: !shouldShow });
     }
   });
-  
+
   // Apply column visibility changes
   if (columnsToUpdate.length > 0) {
     window.globalGridApi.applyColumnState({
@@ -245,8 +270,8 @@ LeafHeaderComponent.prototype.init = function(params) {
 
   // Add custom tooltip with instant display for child headers
   if (typeof addHoverTooltip === 'function') {
-    addHoverTooltip(this.eGui, label.textContent, { 
-      type: 'info', 
+    addHoverTooltip(this.eGui, label.textContent, {
+      type: 'info',
       position: 'top'
     });
   } else {
@@ -265,20 +290,20 @@ LeafHeaderComponent.prototype.init = function(params) {
   navigationArea.style.cursor = 'pointer';
   navigationArea.style.zIndex = '9';
   navigationArea.style.backgroundColor = 'transparent';
-  
+
   this.eGui.appendChild(navigationArea);
 
   navigationArea.addEventListener('click', (event) => {
     event.stopPropagation();
-    
+
     const colDef = params.column?.userProvidedColDef || params.column?.colDef || params.colDef || {};
     const benchmarkIdentifier = colDef.field || colDef.headerName || params.displayName;
-    
+
     if (!benchmarkIdentifier) {
       console.warn('Could not determine benchmark identifier from params:', params);
       return;
     }
-    
+
     const actualBenchmarkId = window.benchmarkIds && window.benchmarkIds[benchmarkIdentifier];
     if (actualBenchmarkId) {
       const domain = 'vision';
@@ -325,11 +350,11 @@ ExpandableHeaderComponent.prototype.init = function(params) {
   const title = document.createElement('span');
   title.className = 'expandable-header-label';
   title.textContent = displayName;
-  
+
   // Add custom tooltip with instant display for parent headers
   if (typeof addHoverTooltip === 'function') {
-    addHoverTooltip(title, displayName, { 
-      type: 'info', 
+    addHoverTooltip(title, displayName, {
+      type: 'info',
       position: 'top'
     });
   } else {
@@ -367,16 +392,16 @@ ExpandableHeaderComponent.prototype.init = function(params) {
     count.className = 'benchmark-count';
     count.style.cursor = 'pointer';
     count.dataset.parentField = colDef.field;
-    
+
     const icon = document.createElement('i');
     icon.className = 'fa-solid fa-up-right-and-down-left-from-center';
     icon.style.marginRight = '4px';
     icon.style.fontSize = '10px';
-    
+
     const countText = document.createElement('span');
     countText.className = 'count-value';
     countText.style.transition = 'all 0.2s ease';
-    
+
     // Calculate initial count
     let initialCount = 0;
     if (window.getFilteredLeafCount && typeof window.getFilteredLeafCount === 'function') {
@@ -394,9 +419,9 @@ ExpandableHeaderComponent.prototype.init = function(params) {
       // For other parent columns, use the number of direct children as fallback
       initialCount = directChildren.length;
     }
-    
+
     countText.textContent = initialCount;
-    
+
     count.appendChild(icon);
     count.appendChild(countText);
     this.eGui.appendChild(count);
@@ -411,24 +436,24 @@ ExpandableHeaderComponent.prototype.init = function(params) {
 
       if (shouldExpand) {
         const directChildIds = directChildren.map(c => c.getColId());
-        
+
         window.columnExpansionState.set(columnId, true);
         const showState = directChildIds.map(id => ({ colId: id, hide: false }));
         params.api.applyColumnState({ state: showState });
-        
+
         const allCols = params.api.getAllGridColumns();
         const parentIndex = allCols.findIndex(col => col.getColId() === columnId);
         if (parentIndex !== -1) {
           const insertIndex = parentIndex + 1;
           params.api.moveColumns(directChildIds, insertIndex);
         }
-        
+
         directChildIds.forEach(childId => {
           window.columnExpansionState.set(childId, false);
         });
-        
+
         icon.className = 'fa-solid fa-down-left-and-up-right-to-center';
-        
+
       } else {
         // Collapse: hide ALL descendants recursively
         const allCols = params.api.getAllGridColumns();
@@ -436,19 +461,19 @@ ExpandableHeaderComponent.prototype.init = function(params) {
           .map(id => allCols.find(col => col.getColId() === id))
           .filter(Boolean)
           .map(col => col.getColId());
-        
+
         // Use applyColumnState
         const hideState = allDescendantIds.map(id => ({ colId: id, hide: true }));
         params.api.applyColumnState({ state: hideState });
-        
+
         // Update expansion state
         window.columnExpansionState.set(columnId, false);
-        
+
         // Mark all descendants as collapsed
         allDescendantIds.forEach(descendantId => {
           window.columnExpansionState.set(descendantId, false);
         });
-        
+
         icon.className = 'fa-solid fa-up-right-and-down-left-from-center';
       }
 
@@ -456,7 +481,7 @@ ExpandableHeaderComponent.prototype.init = function(params) {
       if (toggle) {
         toggle.textContent = shouldExpand ? '▴' : '▾';
       }
-      
+
       // Debounced column visibility update after expand/collapse
       if (window.expandCollapseUpdateTimeout) {
         clearTimeout(window.expandCollapseUpdateTimeout);
@@ -485,9 +510,9 @@ ExpandableHeaderComponent.prototype.init = function(params) {
       if (event.target.closest('.expandable-header .benchmark-count') || event.target.closest('.sort-indicator')) {
         return;
       }
-      
+
       event.stopPropagation();
-      
+
       const column = params.column;
       const colId = column.getColId();
       const currentSort = column.getSort();
@@ -515,4 +540,4 @@ window.LeaderboardHeaderComponents = {
   ExpandableHeaderComponent,
   createSortIndicator,
   updateColumnVisibility
-};
\ No newline at end of file
+};
diff --git a/static/benchmarks/js/leaderboard/ui/ui-handlers.js b/static/benchmarks/js/leaderboard/ui/ui-handlers.js
index b934e07ef..44fad1226 100644
--- a/static/benchmarks/js/leaderboard/ui/ui-handlers.js
+++ b/static/benchmarks/js/leaderboard/ui/ui-handlers.js
@@ -2,7 +2,7 @@
 
 // Setup all UI handlers
 function setupUIHandlers(panel, container, advancedFilterBtn, layoutToggleBtn) {
-  
+
   // Advanced filters panel toggle
   if (advancedFilterBtn && panel) {
     advancedFilterBtn.addEventListener('click', function() {
@@ -26,7 +26,7 @@ function setupUIHandlers(panel, container, advancedFilterBtn, layoutToggleBtn) {
     });
   } else {
   }
-  
+
   // Layout toggle button
   if (layoutToggleBtn && panel && container) {
     layoutToggleBtn.addEventListener('click', function() {
@@ -40,7 +40,7 @@ function setupUIHandlers(panel, container, advancedFilterBtn, layoutToggleBtn) {
       }
     });
   }
-  
+
   // Reset all filters button
   const resetAllFiltersBtn = document.getElementById('resetAllFiltersBtn');
   if (resetAllFiltersBtn) {
@@ -50,36 +50,36 @@ function setupUIHandlers(panel, container, advancedFilterBtn, layoutToggleBtn) {
       }
     });
   }
-  
+
   // Reset benchmarks link
   const resetBenchmarksLink = document.getElementById('resetBenchmarksLink');
   if (resetBenchmarksLink) {
     resetBenchmarksLink.addEventListener('click', function(e) {
       e.preventDefault();
-      
+
       // Check all benchmark checkboxes
       const checkboxes = document.querySelectorAll('#benchmarkFilterPanel input[type="checkbox"]');
       checkboxes.forEach(cb => {
         cb.checked = true;
       });
-      
+
       // Clear filtered benchmarks
       if (window.filteredOutBenchmarks) {
         window.filteredOutBenchmarks.clear();
       }
-      
+
       // Apply filters (skip auto-sort since this is a reset operation, but allow column visibility updates)
       if (typeof window.applyCombinedFilters === 'function') {
         window.applyCombinedFilters(false, true);
       }
     });
   }
-  
+
 }
 
 // Initialize filters from URL parameters or set defaults
 function initializeFilters() {
-  
+
   // Try to parse URL filters first
   if (typeof window.LeaderboardURLState?.parseURLFilters === 'function') {
     try {
@@ -87,7 +87,9 @@ function initializeFilters() {
     } catch (e) {
     }
   }
-  
+
+  const nowUnix = Math.floor(Date.now() / 1000);
+
   // If no URL filters, ensure filters are in default state
   if (!window.activeFilters) {
     window.activeFilters = {
@@ -105,22 +107,24 @@ function initializeFilters() {
       benchmark_regions: [],
       benchmark_species: [],
       benchmark_tasks: [],
-      public_data_only: false
+      public_data_only: false,
+      min_wayback_timestamp: 1598486400,
+      max_wayback_timestamp: nowUnix
     };
   }
-  
+
   // Initialize filtered benchmarks set if not exists
   if (!window.filteredOutBenchmarks) {
     window.filteredOutBenchmarks = new Set();
   }
-  
+
   // Apply initial filters (skip column toggle during initialization)
   if (typeof window.applyCombinedFilters === 'function') {
     setTimeout(() => {
       window.applyCombinedFilters(true);
     }, 100);
   }
-  
+
 }
 
 // Export functions for use by other modules
@@ -132,4 +136,3 @@ window.LeaderboardUIHandlers = {
 // Make functions globally available for compatibility
 window.setupUIHandlers = setupUIHandlers;
 window.initializeFilters = initializeFilters;
-
diff --git a/static/benchmarks/js/leaderboard/utilities/color-utils.js b/static/benchmarks/js/leaderboard/utilities/color-utils.js
new file mode 100644
index 000000000..d89a9e6c8
--- /dev/null
+++ b/static/benchmarks/js/leaderboard/utilities/color-utils.js
@@ -0,0 +1,204 @@
+// Color calculation utilities
+// Replicates the SQL representative_color_sql_precomputed function logic
+
+// Precomputed color arrays matching SQL (101 colors each)
+const REDGREEN_COLORS = [
+  '#ff0000', '#ff0000', '#ff0000', '#ff0000', '#fe0600', '#fe0600', '#fd0d01', '#fd0d01', '#fc1301', '#fb1901', 
+  '#fb1901', '#fa1f02', '#f92502', '#f92502', '#f82b02', '#f73103', '#f73103', '#f63703', '#f53d03', '#f44204', 
+  '#f44204', '#f44804', '#f34d04', '#f25305', '#f15805', '#f15805', '#f05e05', '#ef6306', '#ee6806', '#ed6e06', 
+  '#ec7307', '#eb7807', '#ea7d07', '#e98208', '#e88708', '#e88708', '#e78c08', '#e69109', '#e69509', '#e59a09', 
+  '#e49f0a', '#e3a30a', '#e2a80a', '#e1ac0a', '#e0b10b', '#dfb50b', '#deb90b', '#ddbe0c', '#dcc20c', '#dcc60c', 
+  '#dbca0d', '#d9d20d', '#d8d60d', '#d4d70e', '#cfd60e', '#c9d50e', '#c4d40f', '#bed40f', '#b9d30f', '#b4d20f', 
+  '#aed110', '#a4cf10', '#9fce10', '#9acd11', '#95cc11', '#90cc11', '#8bcb11', '#86ca12', '#7dc812', '#78c712', 
+  '#74c613', '#6fc613', '#6ac513', '#66c413', '#5dc214', '#59c114', '#55c014', '#51c015', '#48be15', '#44bd15', 
+  '#40bc16', '#3cbb16', '#38bb16', '#31b917', '#2db817', '#29b717', '#26b617', '#1eb518', '#1bb418', '#18b319', 
+  '#18b21c', '#19b124', '#19b028', '#19af2b', '#19ad32', '#1aad36', '#1aac39', '#1aaa40', '#1aa943', '#1ba947', 
+  '#1ba84a'
+];
+
+const GRAY_COLORS = [
+  '#f2f2f2', '#f2f2f2', '#f2f2f2', '#f2f2f2', '#f0f0f0', '#f0f0f0', '#eeeeee', '#eeeeee', '#ededed', '#ebebeb', 
+  '#ebebeb', '#e9e9e9', '#e7e7e7', '#e7e7e7', '#e6e6e6', '#e4e4e4', '#e4e4e4', '#e2e2e2', '#e0e0e0', '#dedede', 
+  '#dedede', '#dddddd', '#dbdbdb', '#d9d9d9', '#d7d7d7', '#d7d7d7', '#d6d6d6', '#d4d4d4', '#d2d2d2', '#d0d0d0', 
+  '#cecece', '#cdcdcd', '#cbcbcb', '#c9c9c9', '#c7c7c7', '#c7c7c7', '#c5c5c5', '#c4c4c4', '#c2c2c2', '#c0c0c0', 
+  '#bebebe', '#bdbdbd', '#bbbbbb', '#b9b9b9', '#b7b7b7', '#b5b5b5', '#b4b4b4', '#b2b2b2', '#b0b0b0', '#aeaeae', 
+  '#adadad', '#a9a9a9', '#a7a7a7', '#a5a5a5', '#a4a4a4', '#a2a2a2', '#a0a0a0', '#9e9e9e', '#9d9d9d', '#9b9b9b', 
+  '#999999', '#959595', '#949494', '#929292', '#909090', '#8e8e8e', '#8d8d8d', '#8b8b8b', '#878787', '#858585', 
+  '#848484', '#828282', '#808080', '#7e7e7e', '#7b7b7b', '#797979', '#777777', '#757575', '#727272', '#707070', 
+  '#6e6e6e', '#6c6c6c', '#6b6b6b', '#676767', '#656565', '#646464', '#626262', '#5e5e5e', '#5c5c5c', '#5b5b5b', 
+  '#595959', '#555555', '#545454', '#525252', '#4e4e4e', '#4c4c4c', '#4b4b4b', '#474747', '#454545', '#444444', 
+  '#424242'
+];
+
+const COLOR_NONE = '#e0e1e2';
+const GAMMA = 0.5;  // Gamma value to stretch high-end differences
+
+/**
+ * Calculate representative color for a score value
+ * Replicates the SQL representative_color_sql_precomputed function
+ * 
+ * @param {number} value - The score value
+ * @param {number} minValue - Minimum value in the distribution
+ * @param {number} maxValue - Maximum value in the distribution
+ * @param {string} rootParent - Root parent identifier (e.g., 'engineering_vision_v0')
+ * @returns {string} CSS color string in format "background-color: rgb(...); background-color: rgba(...);"
+ */
+function calculateRepresentativeColor(value, minValue, maxValue, rootParent) {
+  // Return neutral grey if value is null, NaN, or invalid
+  if (value === null || value === undefined || isNaN(value) || value === 'NaN' || value === '') {
+    return `background-color: ${COLOR_NONE};`;
+  }
+  
+  // Normalize the input value between 0 and 1
+  let normalizedValue;
+  if (maxValue - minValue === 0) {
+    normalizedValue = 0.5;
+  } else {
+    normalizedValue = (value - minValue) / (maxValue - minValue);
+  }
+  normalizedValue = Math.max(0, Math.min(1, normalizedValue));
+  
+  // Apply gamma correction to emphasize differences at the top-end
+  normalizedValue = Math.pow(normalizedValue, 1.0 / GAMMA);
+  
+  // Scale down the normalized value (0.8 factor)
+  normalizedValue = 0.8 * normalizedValue;
+  normalizedValue = Math.max(0, Math.min(1, normalizedValue));
+  
+  // Get color array index (0-100)
+  let idx = Math.floor(100 * normalizedValue);
+  if (idx > 100) {
+    idx = 100;
+  }
+  
+  // Determine color palette based on root parent
+  const isEngineering = rootParent && rootParent.toLowerCase().includes('engineering');
+  const colorHex = isEngineering ? GRAY_COLORS[idx] : REDGREEN_COLORS[idx];
+  
+  // Extract RGB values from hex color
+  const r = parseInt(colorHex.substring(1, 3), 16);
+  const g = parseInt(colorHex.substring(3, 5), 16);
+  const b = parseInt(colorHex.substring(5, 7), 16);
+  
+  // Calculate alpha based on value position
+  let alpha;
+  if (maxValue - minValue === 0) {
+    alpha = 1.0;
+  } else {
+    // Linear interpolation: alpha ranges from 0.1 (at min) to 1.0 (at max)
+    // slope = -0.9 / (min_value - max_value)
+    // intercept = 0.1 - slope * min_value
+    const slope = -0.9 / (minValue - maxValue);
+    const intercept = 0.1 - slope * minValue;
+    alpha = slope * value + intercept;
+  }
+  alpha = Math.max(0, Math.min(1, alpha));
+  
+  // Build CSS color string
+  const fallbackColor = `rgb(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)})`;
+  const rgbaColor = `rgba(${r}, ${g}, ${b}, ${alpha.toFixed(2)})`;
+  
+  return `background-color: ${fallbackColor}; background-color: ${rgbaColor};`;
+}
+
+/**
+ * Recalculate colors for a set of benchmarks based on new score distribution
+ * This is used when excluded benchmarks change the min/max ranges
+ * 
+ * @param {Array} rowData - Array of model row data
+ * @param {string} benchmarkId - Benchmark identifier to recalculate colors for
+ * @param {Map} hierarchyMap - Benchmark hierarchy map
+ * @param {Map} rootParentCache - Optional cache of benchmark -> root parent mappings (Priority 2 optimization)
+ * @returns {void} Modifies rowData in place
+ */
+function recalculateColorsForBenchmark(rowData, benchmarkId, hierarchyMap, rootParentCache = null) {
+  // Collect all values for this benchmark across all models
+  const values = [];
+  rowData.forEach(row => {
+    if (row[benchmarkId] && row[benchmarkId].value !== 'X' && row[benchmarkId].value !== null) {
+      const val = row[benchmarkId].value;
+      const numVal = typeof val === 'string' ? parseFloat(val) : val;
+      if (!isNaN(numVal)) {
+        values.push(numVal);
+      }
+    }
+  });
+  
+  if (values.length === 0) {
+    return;  // No valid scores to calculate colors for
+  }
+  
+  const minValue = Math.min(...values);
+  const maxValue = Math.max(...values);
+  
+  // Use cached root parent if available, otherwise traverse hierarchy
+  let rootParent = null;
+  
+  if (rootParentCache && rootParentCache.has(benchmarkId)) {
+    rootParent = rootParentCache.get(benchmarkId);
+  } else {
+    // Fallback: Traverse hierarchy if cache not available
+    let currentId = benchmarkId;
+    const visited = new Set();
+    
+    // Traverse up the hierarchy to find root
+    while (currentId && !visited.has(currentId)) {
+      visited.add(currentId);
+      
+      // Check if currentId is a root (no parent in hierarchy)
+      let hasParent = false;
+      for (const [parentId, children] of hierarchyMap.entries()) {
+        if (children.includes(currentId)) {
+          currentId = parentId;
+          hasParent = true;
+          break;
+        }
+      }
+      
+      if (!hasParent) {
+        // This is a root
+        rootParent = currentId;
+        break;
+      }
+    }
+    
+    // Fallback: if we couldn't determine root parent, infer from benchmarkId
+    if (!rootParent) {
+      // Check if benchmarkId or any ancestor contains 'engineering'
+      const checkId = benchmarkId.toLowerCase();
+      if (checkId.includes('engineering')) {
+        rootParent = 'engineering_vision_v0';
+      } else {
+        // Default to neural for non-engineering benchmarks
+        rootParent = 'neural_vision_v0';
+      }
+    }
+  }
+  
+  // Recalculate colors for each model
+  rowData.forEach(row => {
+    if (row[benchmarkId] && row[benchmarkId].value !== 'X' && row[benchmarkId].value !== null) {
+      const val = row[benchmarkId].value;
+      const numVal = typeof val === 'string' ? parseFloat(val) : val;
+      if (!isNaN(numVal)) {
+        const colorCss = calculateRepresentativeColor(numVal, minValue, maxValue, rootParent);
+        // Extract rgba value from CSS string (format: "background-color: rgb(...); background-color: rgba(...);")
+        // The cell renderer expects just the rgba/rgb value
+        const rgbaMatch = colorCss.match(/rgba?\([^)]*\)/);
+        if (rgbaMatch) {
+          row[benchmarkId].color = rgbaMatch[0];
+        } else {
+          // Fallback to default if no rgba found
+          row[benchmarkId].color = COLOR_NONE;
+        }
+      }
+    }
+  });
+}
+
+// Export functions
+window.LeaderboardColorUtils = {
+  calculateRepresentativeColor,
+  recalculateColorsForBenchmark
+};
+
diff --git a/static/benchmarks/js/leaderboard/utilities/hierarchy-utils.js b/static/benchmarks/js/leaderboard/utilities/hierarchy-utils.js
index 169ac5bc3..10c8c6b5c 100644
--- a/static/benchmarks/js/leaderboard/utilities/hierarchy-utils.js
+++ b/static/benchmarks/js/leaderboard/utilities/hierarchy-utils.js
@@ -31,16 +31,44 @@ function getFilteredLeafCount(parentField) {
       }
     });
     
-    // Count how many are NOT excluded
-    const count = Array.from(allLeafIds).filter(leafId => !excludedBenchmarks.has(leafId)).length;
+    // Count how many are NOT excluded (by benchmark tree) AND not hidden by wayback filtering
+    const count = Array.from(allLeafIds).filter(leafId => {
+      // Exclude if in filteredOutBenchmarks
+      if (excludedBenchmarks.has(leafId)) {
+        return false;
+      }
+      
+      // Also exclude if hidden by wayback filtering
+      if (typeof window.LeaderboardFilterCoordinator?.isColumnHiddenByWaybackFiltering === 'function') {
+        if (window.LeaderboardFilterCoordinator.isColumnHiddenByWaybackFiltering(leafId)) {
+          return false;
+        }
+      }
+      
+      return true;
+    }).length;
     return count;
   }
   
   // For specific categories, get direct leaf descendants
   const leafDescendants = getAllLeafDescendants(parentField, hierarchyMap);
   
-  // Count how many are NOT excluded
-  const count = leafDescendants.filter(leafId => !excludedBenchmarks.has(leafId)).length;
+  // Count how many are NOT excluded (by benchmark tree) AND not hidden by wayback filtering
+  const count = leafDescendants.filter(leafId => {
+    // Exclude if in filteredOutBenchmarks
+    if (excludedBenchmarks.has(leafId)) {
+      return false;
+    }
+    
+    // Also exclude if hidden by wayback filtering
+    if (typeof window.LeaderboardFilterCoordinator?.isColumnHiddenByWaybackFiltering === 'function') {
+      if (window.LeaderboardFilterCoordinator.isColumnHiddenByWaybackFiltering(leafId)) {
+        return false;
+      }
+    }
+    
+    return true;
+  }).length;
   
   return count;
 }