Update app.py

app.py

@@ -1,91 +1,187 @@
 import dash
-from dash import html, dcc, Input, Output, State
+from dash import html, dcc, Input, Output, State, no_update
 import dash_ag_grid as dag
 import pandas as pd
 import numpy as np
 from datetime import datetime, timedelta
 import base64
 import os
+import logging
+import sys
+import json
 
-# Define the columns
-MAIN_COLS = ['#P', 'Model', 'UGI 🏆', 'W/10 👍', 'NatInt 💡', 'Coding 💻', 'Unruly', 'Internet', 'Societal/Political', 'Political Lean 📋', 'Ideology Name']
-AXES_COLS_1 = ['govt', 'dipl', 'econ', 'scty']
-AXES_COLS_2 = ['Federal-Unitary', 'Democratic-Autocratic', 'Security-Freedom', 'Nationalism-Internationalism',
-               'Militarist-Pacifist', 'Assimilationist-Multiculturalist', 'Collectivize-Privatize',
-               'Planned-LaissezFaire', 'Isolationism-Globalism', 'Irreligious-Religious',
-               'Progressive-Traditional', 'Acceleration-Bioconservative']
-UGI_CATEGORY_COLS = ['Unruly', 'Internet', 'Societal/Political']
+# This setup works with the PYTHONUNBUFFERED=1 environment variable.
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+# Helper function to create a checklist option
+def create_option(value, label):
+    return {'label': label, 'value': value}
+
+# Define groups of columns that will be toggled together
+COLUMN_GROUPS = {
+    "uncensored_ugi_cats": ["Hazardous", "Entertainment", "SocPol"],
+    "w10_sub_scores": ["W/10-Direct", "W/10-Adherence"],
+    "natint_sub_scores": ["Standard", "Pop Culture", "World Model"],
+    "writing_repetition_group": [
+        "lexical_stuckness", "originality_score", "internal_semantic_redundancy"
+    ],
+    "writing_style_group": [
+        "Readability_Grade_Level", "Verb_to_Noun_Ratio", "Adjective_Adverb_Percentage", "Dialogue_Percentage"
+    ],
+    "nsfw_dark_group": ["avg_nsfw_score", "avg_dark_score"],
+    "length_adherence_group": ["avg_length_error_pct", "creative_writing_wc_exceeded_pct"],
+    "politics_agg_group": ["govt", "dipl", "econ", "scty"],
+    "politics_axes_group": [
+        'Federal-Unitary', 'Democratic-Autocratic', 'Security-Freedom', 'Nationalism-Internationalism',
+        'Militarist-Pacifist', 'Assimilationist-Multiculturalist', 'Collectivize-Privatize',
+        'Planned-LaissezFaire', 'Isolationism-Globalism', 'Irreligious-Religious',
+        'Progressive-Traditional', 'Acceleration-Bioconservative'
+    ],
+    "world_model_group": [
+        'wm_recipe_percent_error', 'wm_geoguesser_mae', 'wm_weight_percent_error',
+        'wm_music_mae', 'wm_youtube_view_percent_error', 'Show Rec Score',
+        "Show Rec MAE", "Show Rec Pearson", "Show Rec Std Dev Error"
+    ],
+}
+
+# Define the columns for each preset, using group keys for grouped columns
+PRESET_COLUMNS = {
+    "Overview": {
+        "UGI 🏆": "UGI 🏆", "W/10 👍": "W/10 👍", "NatInt 💡": "NatInt 💡", "Writing ✍️": "Writing ✍️",
+        "Political Lean 📋": "Political Lean 📋"
+    },
+    "Uncensored": {
+        "UGI 🏆": "UGI 🏆",
+        "uncensored_ugi_cats": "UGI Categories",
+        "W/10 👍": "W/10 👍",
+        "w10_sub_scores": "W/10 Categories"
+    },
+    "Intelligence": {
+        "NatInt 💡": "NatInt 💡", "natint_sub_scores": "NatInt Categories",
+        "world_model_group": "World Model Tests",
+    },
+    "Writing": {
+        "Writing ✍️": "Writing ✍️",
+        "nsfw_dark_group": "NSFW / Dark Scores",
+        "writing_style_group": "Stylistic Metrics",
+        "writing_repetition_group": "Repetition Metrics",
+        "length_adherence_group": "Length Adherence",
+        "avg_writing_style_score": "Style Adherence",
+    },
+    "Politics": {
+        "Political Lean 📋": "Political Lean 📋", "12axes Ideology": "Ideology",
+        "politics_agg_group": "Aggregate Scores",
+        "politics_axes_group": "12 Axes Scores"
+    }
+}
+
+# Create the checklist options from the preset definitions
+PRESET_OPTIONS = {
+    preset: [create_option(col, label) for col, label in cols.items()]
+    for preset, cols in PRESET_COLUMNS.items()
+}
+
+# Define other toggleable columns that are not part of presets
+OTHER_TOGGLES = {
+    "Prompt Template": "Template",
+    "Architecture": "Architecture",
+    "Avg Thinking Chars": "Avg Thinking Chars"
+}
 
 def load_leaderboard_data(csv_file_path):
     try:
+        # Load the CSV without special boolean handling first
         df = pd.read_csv(csv_file_path, na_values=['NA'])
-        
+
+        # Defensive: remove any leading/trailing whitespace from headers
+        df.columns = df.columns.str.strip()
+        if 'Is Thinking Model' in df.columns:
+            df['Is Thinking Model'] = df['Is Thinking Model'].astype(str).fillna('FALSE').str.strip().str.upper() == 'TRUE'
+        else:
+            df['Is Thinking Model'] = False
+
         # Add type sort value
         def get_type_sort_value(row):
             if pd.isna(row['Total Parameters']):
-                return 3  # P
+                return 3  # P (Proprietary)
             if row['Is Foundation'] and not row['Is Merged']:
-                return 0  # B
+                return 0  # B (Base)
             if row['Is Merged']:
-                return 2  # M
+                return 2  # M (Merge)
             if row['Is Finetuned'] and not row['Is Merged']:
-                return 1  # F
-            return 4
+                return 1  # F (Finetune)
+            return 4 # Unknown
 
         df['model_type_sort'] = df.apply(get_type_sort_value, axis=1)
-        
+        df['type'] = df['model_type_sort']
+
         # Convert date columns to datetime
         for col in ['Release Date', 'Test Date']:
             df[col] = pd.to_datetime(df[col], format='%m/%d/%Y', errors='coerce')
-        
-        # Store original release date for sorting (earliest first for tertiary sort)
+
+        # Store original release date for sorting
         df['Release_Date_Sort'] = df['Release Date']
-        
-        # Create a multi-tiered sorting key
-        # 1. UGI score (highest first) - primary sort
-        # 2. NatInt score (highest first) - secondary sort for same UGI
-        # 3. Release Date (earliest first) - tertiary sort for same UGI and NatInt
-        
+
         # Format dates as strings for display
         df['Release Date'] = df['Release Date'].dt.strftime('%Y-%m-%d')
         df['Test Date'] = df['Test Date'].dt.strftime('%Y-%m-%d')
-        
-        # Calculate the date two weeks ago from today
-        two_weeks_ago = (datetime.now() - timedelta(days=6)).strftime('%Y-%m-%d') #temp 6
-        
-        # Store model name and link separately
-        df['Model_Link'] = df['Model Link'].fillna('')
-        df['Model_Display'] = df['author/model_name']
-        
-        # Check for new models based on Test Date
+
+        # Calculate the date for the 'new' emoji
+        two_weeks_ago = (datetime.now() - timedelta(days=2)).strftime('%Y-%m-%d') # temp set to 2
         df['is_new'] = df.apply(
             lambda row: '🆕' if pd.notna(row["Test Date"]) and row["Test Date"] >= two_weeks_ago else '',
             axis=1
         )
-        
+
+        # Store model name and link separately
+        df['Model_Link'] = df['Model Link'].fillna('')
+        df['Model_Display'] = df['author/model_name']
+
         # Add pinned and selected columns
         df['pinned'] = False
         df['selected'] = False
-        
-        # Convert percentage strings to floats for all relevant columns
-        percentage_columns = ['Political Lean 📋'] + AXES_COLS_1 + AXES_COLS_2
+
+        # Flatten the list of political columns, expanding group keys into their actual column names
+        politics_keys = list(PRESET_COLUMNS['Politics'].keys())
+        all_politics_individual_cols = []
+        for key in politics_keys:
+            if key in COLUMN_GROUPS:
+                all_politics_individual_cols.extend(COLUMN_GROUPS[key])
+            else:
+                all_politics_individual_cols.append(key)
+
+        # Now, process only the real columns that are percentages
+        percentage_columns = [col for col in all_politics_individual_cols if col != '12axes Ideology']
         for col in percentage_columns:
-            df[col] = pd.to_numeric(df[col].astype(str).str.rstrip('%'), errors='coerce')
-        
-        # Round numeric columns and handle NA values
-        numeric_columns = df.select_dtypes(include=[np.number]).columns
-        for col in numeric_columns:
-            df[col] = df[col].apply(lambda x: None if pd.isna(x) else round(x, 3))
+            if col in df.columns: # Check if the column exists before processing
+                df[col] = pd.to_numeric(df[col].astype(str).str.rstrip('%'), errors='coerce')
+
+        # Replace NaN with large/small numbers for sorting, which serialize reliably to JSON
+        # Higher is better -> fill with a very small number so they sort last when descending
+        df['Show Rec Score'].fillna(-99999, inplace=True)
+        df['Show Rec Pearson'].fillna(-99999, inplace=True)
+        # Lower is better -> fill with a very large number so they sort last when ascending
+        df['Show Rec MAE'].fillna(99999, inplace=True)
+        df['Show Rec Std Dev Error'].fillna(99999, inplace=True)
 
-        # Sort with multiple keys in the required order
+        # Sort with multiple keys
         df = df.sort_values(
-            by=['UGI 🏆', 'NatInt 💡', 'Release_Date_Sort'], 
-            ascending=[False, False, True]  # UGI desc, NatInt desc, Release date asc (earliest first)
+            by=['UGI 🏆', 'NatInt 💡', 'Release_Date_Sort'],
+            ascending=[False, False, True]
         )
-        
+
         return df
     except Exception as e:
         print(f"Error loading CSV file: {e}")
+        # Print the full traceback to help debug future issues
+        import traceback
+        traceback.print_exc()
         return pd.DataFrame()
 
 def load_ideology_descriptions():
@@ -148,6 +244,7 @@ app.index_string = '''
                 --secondary-text: #666;
                 --pinned-bg: #f5f5f5;
                 --border-color: #ccc;
+                --preset-bg: #f9f9f9;
             }
             @media (prefers-color-scheme: dark) {
                 :root {
@@ -159,6 +256,7 @@ app.index_string = '''
                     --secondary-text: #8b949e;
                     --pinned-bg: #1c2128;
                     --border-color: #30363d;
+                    --preset-bg: #1c2128;
                     color-scheme: dark;
                 }
                 .ag-theme-alpine .ag-menu {
@@ -250,6 +348,11 @@ app.index_string = '''
                 --ag-foreground-color: var(--text-color);
                 --ag-row-border-color: var(--grid-border);
             }
+            body .ag-theme-alpine .ag-header-cell,
+            body .ag-theme-alpine .ag-cell {
+                padding-left: 10px;
+                padding-right: 10px;
+            }
             .ag-theme-alpine .ag-pinned-left-header,
             .ag-theme-alpine .ag-cell-last-left-pinned {
                 border-right: 2px solid var(--grid-border) !important;
@@ -312,6 +415,41 @@ app.index_string = '''
             .border-right {
                 border-right: 2px solid var(--grid-border) !important;
             }
+            .border-left-dashed {
+                border-left: 2px dashed var(--grid-border) !important;
+                margin-left: -2px !important;
+            }
+            
+            .preset-container {
+                display: flex;
+                flex-direction: row;
+                gap: 15px;
+                justify-content: space-between;
+            }
+            .preset-column {
+                flex: 1;
+                padding: 10px;
+                border: 1px solid var(--grid-border);
+                border-radius: 8px;
+                background-color: var(--preset-bg);
+            }
+            .preset-selector label {
+                font-size: 1.2em !important;
+                display: flex;
+                align-items: center;
+            }
+            .preset-selector input[type="radio"] {
+                width: 1.1em;
+                height: 1.1em;
+            }
+            .preset-selector .dash-radioitems {
+                font-size: 1.2em;
+            }
+            .preset-checklist {
+                margin-top: 10px;
+                padding-left: 5px;
+            }
+            
             /* Link Styles */
             .model-link {
                 color: var(--link-color) !important;
@@ -428,12 +566,112 @@ app.index_string = '''
             .split-header-top, .split-header-bottom {
                 white-space: nowrap;
             }
-            .ag-theme-alpine .new-emoji-cell.ag-cell {
-                font-size: 18px !important;
+            
+            @media (max-width: 800px) {
+                .ag-theme-alpine .ag-pinned-left-cols-container,
+                .ag-theme-alpine .ag-pinned-left-header {
+                    position: static !important;
+                    box-shadow: none !important;
+                    border-right: none !important;
+                }
+                .ag-theme-alpine .ag-cell-last-left-pinned {
+                    border-right: 1px solid var(--grid-border) !important;
+                }
+            }
+            #model-type-filter .dash-checklist-item {
+                font-weight: normal;
+                margin-right: 15px;
+            }
+            /* This rule adds the divider to the container of the last item */
+            #model-type-filter .dash-checklist-item:last-of-type {
+                border-left: 1px solid var(--border-color);
+                margin-left: 10px;
+                padding-left: 15px;
+            }
+            
+            .center-aligned-header .ag-header-cell-label {
+                justify-content: center !important;
+            }
+            .ag-header-cell[col-id="pinned"],
+            .ag-cell[col-id="pinned"],
+            .ag-header-cell[col-id="is_new"],
+            .ag-cell[col-id="is_new"],
+            .ag-header-cell[col-id="R"],
+            .ag-cell[col-id="R"],
+            .ag-header-cell[col-id="type"],
+            .ag-cell[col-id="type"] {
+                padding-left: 0px !important;
+                padding-right: 0px !important;
                 display: flex !important;
                 align-items: center !important;
-                justify-content: flex-start !important;
-                padding-left: 12px !important;
+                justify-content: center !important;
+                text-align: center !important;
+            }
+            
+            .ag-cell[col-id="is_new"] {
+                padding-left: 0px !important;
+                padding-right: 0px !important;
+                font-size: 18px;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+            }
+            
+            .header-optimal-len-err .ag-header-cell-text::after {
+                content: ' (0)';
+                color: #CC5500 !important;
+                font-weight: normal;
+                font-family: inherit;
+                font-size: inherit;
+            }
+            .header-optimal-natint .ag-header-cell-text::after {
+                content: ' (higher)';
+                color: #CC5500 !important;
+                font-weight: normal;
+                font-family: inherit;
+                font-size: inherit;
+            }
+            .header-optimal-orig .ag-header-cell-text::after {
+                content: ' (higher)';
+                color: #CC5500 !important;
+                font-weight: normal;
+                font-family: inherit;
+                font-size: inherit;
+            }
+            .header-optimal-sem-red .ag-header-cell-text::after {
+                content: ' (lower)';
+                color: #CC5500 !important;
+                font-weight: normal;
+                font-family: inherit;
+                font-size: inherit;
+            }
+            .header-optimal-lex-stuck .ag-header-cell-text::after {
+                content: ' (lower)';
+                color: #CC5500 !important;
+                font-weight: normal;
+                font-family: inherit;
+                font-size: inherit;
+            }
+            .header-optimal-adj-adv .ag-header-cell-text::after {
+                content: ' (~13.5)';
+                color: #CC5500 !important;
+                font-weight: normal;
+                font-family: inherit;
+                font-size: inherit;
+            }
+            .header-optimal-read-grade .ag-header-cell-text::after {
+                content: ' (~5.5)';
+                color: #CC5500 !important;
+                font-weight: normal;
+                font-family: inherit;
+                font-size: inherit;
+            }
+            .header-optimal-dialogue .ag-header-cell-text::after {
+                content: ' (~60)';
+                color: #CC5500 !important;
+                font-weight: normal;
+                font-family: inherit;
+                font-size: inherit;
             }
         </style>
     </head>
@@ -451,8 +689,14 @@ app.index_string = '''
 # Load data
 df = load_leaderboard_data("ugi-leaderboard-data.csv")
 
-# Define helper functions
-def create_numeric_column(field, width=125, sort=None, sortIndex=None, **kwargs):
+def create_numeric_column(field, width=125, **kwargs):
+    base_classes = "ag-left-aligned-cell"
+    custom_class = kwargs.get("cellClass", "")
+    if isinstance(custom_class, list):
+        custom_class = " ".join(custom_class)
+    final_cell_class = f"{base_classes} {custom_class}".strip()
+    incoming_filter_params = kwargs.pop('filterParams', {})
+
     column = {
         "field": field,
         "width": width,
@@ -461,35 +705,27 @@ def create_numeric_column(field, width=125, sort=None, sortIndex=None, **kwargs)
             "defaultOption": "inRange",
             "filterOptions": ['equals', 'notEqual', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'inRange']
         },
+        "valueFormatter": {"function": "params.value == null ? '' : String(params.value)"},
         "headerClass": "ag-left-aligned-header wrap-text",
-        "cellClass": "ag-left-aligned-cell",
+        "cellClass": final_cell_class,
         "wrapHeaderText": True,
         "autoHeaderHeight": True,
         "suppressSizeToFit": True,
         "sortingOrder": ['desc', 'asc'],
-        "comparator": {
-            "function": """
-                function(valueA, valueB, nodeA, nodeB, isInverted) {
-                    const a = nodeA.data.__sortValue;
-                    const b = nodeB.data.__sortValue;
-                    return a - b;
-                }
-            """
-        }
     }
-    
-    # Update filterParams if provided in kwargs
-    if 'filterParams' in kwargs:
-        column['filterParams'].update(kwargs['filterParams'])
-        
-    if sort:
-        column["sort"] = sort
-    if sortIndex is not None:
-        column["sortIndex"] = sortIndex
+    column['filterParams'].update(incoming_filter_params)
+    column.update(kwargs)
     return column
-    
-def create_text_column(field, width=120):
-    return {
+
+def create_text_column(field, width=120, **kwargs):
+    base_classes = "ag-left-aligned-cell"
+    custom_class = kwargs.get("cellClass", "")
+    if isinstance(custom_class, list):
+        custom_class = " ".join(custom_class)
+    final_cell_class = f"{base_classes} {custom_class}".strip()
+    incoming_filter_params = kwargs.pop('filterParams', {})
+
+    column = {
         "field": field,
         "width": width,
         "filter": "agTextColumnFilter",
@@ -498,215 +734,13 @@ def create_text_column(field, width=120):
             "filterOptions": ['contains', 'notContains', 'startsWith', 'endsWith']
         },
         "headerClass": "ag-left-aligned-header wrap-text",
-        "cellClass": "ag-left-aligned-cell",
-        "wrapHeaderText": True,
-        "autoHeaderHeight": True
-    }
-
-# Define column configurations
-columnDefs = [
-    {
-        "headerName": "📌",
-        "field": "pinned",
-        "width": 55,
-        "filter": False,
-        "suppressMenu": True,
-        "cellRenderer": "PinRenderer",
-        "pinned": "left"
-    },
-    {
-        "headerName": "",
-        "field": "is_new",
-        "width": 55,
-        "filter": False,
-        "suppressMenu": True,
-        "cellClass": "new-emoji-cell",
-        "pinned": "left"
-    },
-    {
-        "field": "#P",
-        "width": 115,
-        "filter": "agNumberColumnFilter",
-        "filterParams": {
-            "defaultOption": "equals",
-            "filterOptions": ['equals', 'notEqual', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'inRange']
-        },
-        "headerClass": "ag-left-aligned-header wrap-text",
-        "cellClass": "ag-right-aligned-cell",
-        "wrapHeaderText": True,
-        "autoHeaderHeight": True,
-        "suppressSizeToFit": True,
-        "sortingOrder": ['desc', 'asc'],
-        "pinned": "left"
-    },
-    {
-        "field": "model_type_sort",
-        "hide": True
-    },
-    {
-        "headerName": "T",
-        "field": "model_type_sort",  # Changed to use the sort field directly
-        "width": 45,
-        "filter": False,
-        "suppressMenu": True,
-        "cellRenderer": "TypeRenderer",
-        "pinned": "left",
-        "sortable": True,
-        "sortingOrder": ['asc', 'desc']
-    },
-    {
-        "field": "Model_Display",
-        "headerName": "Model",
-        "cellRenderer": "ModelLink",
-        "filter": "agTextColumnFilter",
-        "filterParams": {
-            "defaultOption": "contains",
-            "filterOptions": ['contains', 'notContains', 'startsWith', 'endsWith']
-        },
-        "width": 380,
-        "suppressMenu": False,
-        "pinned": "left",
-        "headerClass": "ag-left-aligned-header wrap-text",
-        "wrapHeaderText": True,
-        "autoHeaderHeight": True
-    },
-    {
-        "field": "UGI 🏆",
-        "width": 120,
-        "filter": "agNumberColumnFilter",
-        "filterParams": {
-            "defaultOption": "greaterThanOrEqual"
-        },
-        "headerClass": "ag-left-aligned-header wrap-text",
-        "cellClass": ["ag-left-aligned-cell", "border-left"],
+        "cellClass": final_cell_class,
         "wrapHeaderText": True,
         "autoHeaderHeight": True,
-        "suppressSizeToFit": True,
-        "sortingOrder": ['desc', 'asc']
-    },
-    create_numeric_column("W/10 👍", width=130, filterParams={
-        "defaultOption": "greaterThanOrEqual",
-        "filterOptions": ['equals', 'notEqual', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'inRange']
-    }),
-    {
-        "field": "NatInt 💡",
-        "headerName": "NatInt 💡",
-        "width": 140,
-        "filter": "agNumberColumnFilter",
-        "filterParams": {
-            "defaultOption": "greaterThanOrEqual",
-            "filterOptions": ['equals', 'notEqual', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'inRange']
-        },
-        "headerClass": "ag-left-aligned-header wrap-text",
-        "cellClass": ["ag-left-aligned-cell", "border-left"],
-        "wrapHeaderText": True,
-        "autoHeaderHeight": True,
-        "suppressSizeToFit": True,
-        "sortingOrder": ['desc', 'asc']
-    },
-    create_numeric_column("Coding 💻", width=140, filterParams={
-        "defaultOption": "greaterThanOrEqual"
-    }),
-    {
-        "field": "Political Lean 📋",
-        "width": 175,
-        "filter": "agNumberColumnFilter",
-        "filterParams": {
-            "defaultOption": "inRange",
-            "filterOptions": ['equals', 'notEqual', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'inRange']
-        },
-        "valueFormatter": {
-            "function": "d3.format('.1f')(params.value) + '%'"
-        },
-        "sortingOrder": ['desc', 'asc'],
-        "headerClass": "ag-left-aligned-header wrap-text",
-        "cellClass": "ag-left-aligned-cell",
-        "wrapHeaderText": True,
-        "autoHeaderHeight": True
     }
-]
-
-ugi_category_columns = [
-    create_numeric_column(col, width=120) for col in UGI_CATEGORY_COLS
-]
-
-w10_type_columns = [
-    create_numeric_column("W/10-Direct", width=120, filterParams={
-        "defaultOption": "greaterThanOrEqual",
-        "filterOptions": ['equals', 'notEqual', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'inRange']
-    }),
-    create_numeric_column("W/10-Adherence", width=120, filterParams={
-        "defaultOption": "greaterThanOrEqual",
-        "filterOptions": ['equals', 'notEqual', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'inRange']
-    })
-]
-
-political_columns = [
-    {
-        "headerName": "12axes Ideology",
-        "field": "Ideology Name",
-        "width": 160,
-        "filter": "agTextColumnFilter",
-        "filterParams": {
-            "defaultOption": "contains",
-            "filterOptions": ['contains', 'notContains', 'startsWith', 'endsWith']
-        },
-        "headerClass": "ag-left-aligned-header wrap-text",
-        "cellClass": "ag-left-aligned-cell",
-        "wrapHeaderText": True,
-        "autoHeaderHeight": True
-    }
-]
-
-template_column = {
-    "field": "Prompt Template",
-    "headerName": "Template",
-    "width": 160,
-    "filter": "agTextColumnFilter",
-    "filterParams": {
-        "defaultOption": "contains",
-        "filterOptions": ['contains', 'notContains', 'startsWith', 'endsWith']
-    },
-    "headerClass": "ag-left-aligned-header wrap-text",
-    "cellClass": "ag-left-aligned-cell",
-    "wrapHeaderText": True,
-    "autoHeaderHeight": True,
-    "comparator": {
-        "function": """
-            function(valueA, valueB) {
-                if (!valueA && !valueB) return 0;
-                if (!valueA) return 1;
-                if (!valueB) return -1;
-                return valueA.toLowerCase().localeCompare(valueB.toLowerCase());
-            }
-        """
-    }
-}
-
-# Add axes columns with different widths
-for i, col in enumerate(AXES_COLS_1):
-    col_def = {
-        "field": col,
-        "width": 105,
-        "filter": "agNumberColumnFilter",
-        "filterParams": {
-            "defaultOption": "inRange",
-            "filterOptions": ['equals', 'notEqual', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'inRange']
-        },
-        "valueFormatter": {
-            "function": "d3.format('.1f')(params.value) + '%'"
-        },
-        "headerClass": "ag-left-aligned-header wrap-text",
-        "cellClass": ["ag-left-aligned-cell"],
-        "sortingOrder": ['desc', 'asc']
-    }
-    
-    if i == 0:  # First column (govt)
-        col_def["cellClass"].append("border-left")
-    elif i == len(AXES_COLS_1) - 1:  # Last column (scty)
-        col_def["cellClass"].append("border-right")
-        
-    columnDefs.append(col_def)
+    column['filterParams'].update(incoming_filter_params)
+    column.update(kwargs)
+    return column
     
 template_with_split_header = """
 <div class="ag-cell-label-container" role="presentation">
@@ -726,94 +760,171 @@ template_with_split_header = """
 </div>
 """
 
-for col in AXES_COLS_2:
-    high, low = col.split('-')
-    columnDefs.append({
-        "field": col,
-        "headerComponentParams": {
-            "template": template_with_split_header.format(high=high, low=low)
-        },
-        "width": 175,
-        "filter": "agNumberColumnFilter",
-        "filterParams": {
-            "defaultOption": "inRange",
-            "filterOptions": ['equals', 'notEqual', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'inRange']
-        },
-        "valueFormatter": {
-            "function": "d3.format('.1f')(params.value) + '%'"
-        },
-        "sortingOrder": ['desc', 'asc']
-    })
+template_with_optimal_value = """
+<div class="ag-cell-label-container" role="presentation">
+    <span ref="eMenu" class="ag-header-icon ag-header-cell-menu-button"></span>
+    <div ref="eLabel" class="ag-header-cell-label" role="presentation">
+        
+        <!-- This new wrapper div takes the place of the original text span. -->
+        <!-- It inherits the expanding behavior, but acts as a container. -->
+        <div class="ag-header-cell-text" style="display: flex; align-items: center;">
+            
+            <!-- The ref="eText" span is now INSIDE our container. AG Grid will still populate it with the column name. -->
+            <span ref="eText"></span>
+            
+            <!-- The optimal value is its sibling, so it will always stay right next to it. -->
+            <span style="color: red; font-weight: normal; padding-left: 5px; white-space: nowrap;">{optimal}</span>
+        </div>
+        <!-- The icons remain outside the wrapper, positioned correctly to the right. -->
+        <span ref="eSortOrder" class="ag-header-icon ag-sort-order"></span>
+        <span ref="eSortAsc" class="ag-header-icon ag-sort-ascending-icon"></span>
+        <span ref="eSortDesc" class="ag-header-icon ag-sort-descending-icon"></span>
+        <span ref="eSortNone" class="ag-header-icon ag-sort-none-icon"></span>
+        <span ref="eFilter" class="ag-header-icon ag-filter-icon"></span>
+    </div>
+</div>
+"""
+
+# This master list defines the final, non-negotiable order of columns in the grid.
+MASTER_COLUMN_ORDER = [
+    "pinned", "is_new", "R", "Avg Thinking Chars", "#P", "type", "Model_Display",
+    # Other Toggles
+    "Prompt Template", "Architecture",
+    # Uncensored
+    "UGI 🏆", "Hazardous", "Entertainment", "SocPol",
+    "W/10 👍", "W/10-Direct", "W/10-Adherence",
+    # Intelligence
+    "NatInt 💡",
+    "Standard", "Pop Culture", "World Model",
+    'wm_recipe_percent_error', 'wm_geoguesser_mae', 'wm_weight_percent_error',
+    'wm_music_mae', 'wm_youtube_view_percent_error',
+    "Show Rec Score", # Main Score
+    "Show Rec MAE", "Show Rec Pearson", "Show Rec Std Dev Error",
+    # Writing
+    "Writing ✍️",
+    "avg_nsfw_score", "avg_dark_score",
+    "Readability_Grade_Level", "Verb_to_Noun_Ratio", "Adjective_Adverb_Percentage", "Dialogue_Percentage",
+    "lexical_stuckness", "originality_score", "internal_semantic_redundancy",
+    "avg_length_error_pct", "creative_writing_wc_exceeded_pct",
+    "avg_writing_style_score",
+    # Politics
+    "Political Lean 📋",
+    "12axes Ideology", "govt", "dipl", "econ", "scty",
+    'Federal-Unitary', 'Democratic-Autocratic', 'Security-Freedom', 'Nationalism-Internationalism',
+    'Militarist-Pacifist', 'Assimilationist-Multiculturalist', 'Collectivize-Privatize',
+    'Planned-LaissezFaire', 'Isolationism-Globalism', 'Irreligious-Religious',
+    'Progressive-Traditional', 'Acceleration-Bioconservative',
+    # Always at the end
+    "Release Date", "Test Date"
+]
+
+# Master dictionary containing definitions for ALL possible columns
+ALL_COLUMN_DEFS = {
+    # --- Always Visible ---
+    "pinned": {"headerName": "📌", "field": "pinned", "width": 40, "minWidth": 40, "filter": False, "suppressMenu": True, "cellRenderer": "PinRenderer", "suppressSizeToFit": True, "headerClass": "center-aligned-header"},
+    "is_new": {"headerName": "", "field": "is_new", "width": 30, "minWidth": 30, "filter": False, "suppressMenu": True, "suppressSizeToFit": True},
+    "R": {"headerName": "R", "field": "Is Thinking Model", "cellRenderer": "ReasoningRenderer", "width": 34, "minWidth": 34, "filter": False, "suppressMenu": True, "sortable": True, "suppressSizeToFit": True, "headerClass": "center-aligned-header"},
+    "#P": {"field": "#P", "width": 105, "filter": "agNumberColumnFilter", "filterParams": {"defaultOption": "equals"}, "headerClass": "ag-left-aligned-header wrap-text", "cellClass": "ag-right-aligned-cell", "wrapHeaderText": True, "autoHeaderHeight": True, "suppressSizeToFit": True, "sortingOrder": ['desc', 'asc']},
+    "type": {"headerName": "T", "field": "type", "width": 32, "minWidth": 32, "filter": False, "suppressMenu": True, "cellRenderer": "TypeRenderer", "sortable": True, "sortingOrder": ['asc', 'desc'], "suppressSizeToFit": True, "headerClass": "center-aligned-header"},
+    "Model_Display": {"field": "Model_Display", "headerName": "Model", "cellRenderer": "ModelLink", "filter": "agTextColumnFilter", "filterParams": {"defaultOption": "contains"}, "width": 395, "suppressMenu": False, "headerClass": "ag-left-aligned-header wrap-text", "wrapHeaderText": True, "autoHeaderHeight": True},
+    "Release Date": {"field": "Release Date", "width": 105, "filter": "agDateColumnFilter", "filterParams": {"browserDatePicker": True, "inRangeInclusive": True, "defaultOption": "greaterThan"}, "cellClass": ["ag-left-aligned-cell", "border-left"], "headerClass": "ag-left-aligned-header wrap-text", "wrapHeaderText": True, "autoHeaderHeight": True, "sortable": True},
+    "Test Date": {"field": "Test Date", "width": 105, "filter": "agDateColumnFilter", "filterParams": {"browserDatePicker": True, "inRangeInclusive": True, "defaultOption": "greaterThan"}, "cellClass": "ag-left-aligned-cell", "headerClass": "ag-left-aligned-header wrap-text", "wrapHeaderText": True, "autoHeaderHeight": True, "sortable": True},
+
+    # --- Main Scores (Overview Columns) ---
+    "UGI 🏆": create_numeric_column("UGI 🏆", headerName="UGI 🏆", width=120, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "W/10 👍": create_numeric_column("W/10 👍", headerName="W/10 👍", width=130, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "NatInt 💡": create_numeric_column("NatInt 💡", headerName="NatInt 💡", width=140, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "Writing ✍️": create_numeric_column("Writing ✍️", headerName="Writing ✍️", width=135, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "Political Lean 📋": create_numeric_column("Political Lean 📋", headerName="Political Lean 📋", width=135, valueFormatter={"function": "params.value == null ? '' : params.value.toFixed(1) + '%'"}, filterParams={"defaultOption": "inRange"}),
+
+    # --- UGI Categories ---
+    "Hazardous": create_numeric_column("Hazardous", width=120, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "Entertainment": create_numeric_column("Entertainment", width=122, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "SocPol": create_numeric_column("SocPol", width=120, filterParams={"defaultOption": "greaterThanOrEqual"}),
+
+    # --- W/10 Types ---
+    "W/10-Direct": create_numeric_column("W/10-Direct", width=120, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "W/10-Adherence": create_numeric_column("W/10-Adherence", width=120, filterParams={"defaultOption": "greaterThanOrEqual"}),
+
+    # --- NatInt Categories ---
+    "Standard": create_numeric_column("Standard", width=120, cellClass="border-left", filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "Pop Culture": create_numeric_column("Pop Culture", width=120, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "World Model": create_numeric_column("World Model", width=120, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    'wm_recipe_percent_error': create_numeric_column('wm_recipe_percent_error', headerName="Cooking (% Error)", width=120, cellClass="border-left", filterParams={"defaultOption": "lessThanOrEqual"}, sortingOrder=['asc', 'desc']),
+    'wm_geoguesser_mae': create_numeric_column('wm_geoguesser_mae', headerName="GeoGuesser (km Error)", width=120, filterParams={"defaultOption": "lessThanOrEqual"}, sortingOrder=['asc', 'desc']),
+    'wm_weight_percent_error': create_numeric_column('wm_weight_percent_error', headerName="Weight (% Error)", width=120, filterParams={"defaultOption": "lessThanOrEqual"}, sortingOrder=['asc', 'desc']),
+    'wm_music_mae': create_numeric_column('wm_music_mae', headerName="Music (Error)", width=120, filterParams={"defaultOption": "lessThanOrEqual"}, sortingOrder=['asc', 'desc']),
+    'wm_youtube_view_percent_error': create_numeric_column('wm_youtube_view_percent_error', headerName="YouTube Views (% Error)", width=126, filterParams={"defaultOption": "lessThanOrEqual"}, sortingOrder=['asc', 'desc']),
+    "Show Rec Score": create_numeric_column(
+        "Show Rec Score", 
+        headerName="Show Rec Score", 
+        width=120, 
+        filterParams={"defaultOption": "greaterThanOrEqual"},
+        valueFormatter={"function": "params.value === -99999 ? '' : String(params.value)"}
+    ),
+    "Show Rec MAE": create_numeric_column(
+        "Show Rec MAE", 
+        headerName="Show Rec MAE", 
+        width=120, 
+        filterParams={"defaultOption": "lessThanOrEqual"}, 
+        sortingOrder=['asc', 'desc'],
+        valueFormatter={"function": "params.value === 99999 ? '' : String(params.value)"},
+        cellClass="border-left-dashed"
+    ),
+    "Show Rec Pearson": create_numeric_column(
+        "Show Rec Pearson",  
+        headerName="Show Rec Pearson", 
+        width=120, 
+        filterParams={"defaultOption": "greaterThanOrEqual"},
+        # Add this formatter to hide the placeholder
+        valueFormatter={"function": "params.value === -99999 ? '' : String(params.value)"}
+    ),
+    "Show Rec Std Dev Error": create_numeric_column(
+        "Show Rec Std Dev Error", 
+        headerName="Show Rec Std Dev Error", 
+        width=120, 
+        filterParams={"defaultOption": "lessThanOrEqual"}, 
+        sortingOrder=['asc', 'desc'],
+        # Add this formatter to hide the placeholder
+        valueFormatter={"function": "params.value === 99999 ? '' : String(params.value)"}
+    ),
     
-# Date Columns
-columnDefs.extend([
-    {
-        "field": "Release Date",
-        "width": 130,
-        "filter": "agDateColumnFilter",
-        "filterParams": {
-            "defaultOption": "greaterThan",
-            "browserDatePicker": True,
-            "inRangeInclusive": True
-        },
-        "filterValueGetter": {
-            "function": """
-                function(params) {
-                    if (!params.data['Release Date']) return null;
-                    const [year, month, day] = params.data['Release Date'].split('-');
-                    return new Date(year, month - 1, day);
-                }
-            """
-        },
-        "valueFormatter": {
-            "function": """
-                function(params) {
-                    if (!params.value) return '';
-                    const [year, month, day] = params.value.split('-');
-                    return `${month}/${day}/${year}`;
-                }
-            """
-        },
-        "cellClass": ["ag-left-aligned-cell", "border-left"],
-        "headerClass": "ag-left-aligned-header wrap-text",
-        "wrapHeaderText": True,
-        "autoHeaderHeight": True,
-        "sortable": True
+    # --- Writing Categories ---
+    "avg_nsfw_score": create_numeric_column("avg_nsfw_score", headerComponentParams={"template": template_with_split_header.format(high='NSFW', low='SFW')}, width=105, cellClass="border-left", filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "avg_dark_score": create_numeric_column("avg_dark_score", headerComponentParams={"template": template_with_split_header.format(high='Dark', low='Tame')}, width=105, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "Dialogue_Percentage": create_numeric_column("Dialogue_Percentage", headerName="Dialogue %", width=110, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "Verb_to_Noun_Ratio": create_numeric_column("Verb_to_Noun_Ratio", headerName="Verb/Noun Ratio", width=123, filterParams={"defaultOption": "inRange"}),
+    "Adjective_Adverb_Percentage": create_numeric_column("Adjective_Adverb_Percentage", headerName="Adj&Adv %", width=115, filterParams={"defaultOption": "inRange"}),
+    "Readability_Grade_Level": create_numeric_column("Readability_Grade_Level", headerName="Readability Grade", width=124, cellClass="border-left", filterParams={"defaultOption": "inRange"}, sortingOrder=['desc', 'asc']),
+    "avg_writing_style_score": create_numeric_column("avg_writing_style_score", headerName="Style Adherence", width=121, cellClass="border-left", filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "avg_length_error_pct": create_numeric_column("avg_length_error_pct", headerName="Length Error %", width=113, cellClass="border-left", filterParams={"defaultOption": "lessThanOrEqual"}, sortingOrder=['asc', 'desc']),
+    "creative_writing_wc_exceeded_pct": create_numeric_column("creative_writing_wc_exceeded_pct", headerName="Exceeded %", width=118, filterParams={"defaultOption": "inRange"}),
+    "originality_score": create_numeric_column("originality_score", headerName="Originality", width=120, filterParams={"defaultOption": "greaterThanOrEqual"}),
+    "internal_semantic_redundancy": create_numeric_column("internal_semantic_redundancy", headerName="Semantic Redundancy", width=125, filterParams={"defaultOption": "lessThanOrEqual"}, sortingOrder=['asc', 'desc']),
+    "lexical_stuckness": create_numeric_column("lexical_stuckness", headerName="Lexical Stuckness", width=118, cellClass="border-left", filterParams={"defaultOption": "lessThanOrEqual"}, sortingOrder=['asc', 'desc']),
+    
+    # --- Politics ---
+    "12axes Ideology": create_text_column("12axes Ideology", width=170, cellClass="border-left", filterParams={"defaultOption": "contains"}),
+    "govt": create_numeric_column("govt", width=105, valueFormatter={"function": "params.value == null ? '' : params.value.toFixed(1) + '%'"}, cellClass="border-left", filterParams={"defaultOption": "inRange"}),
+    "dipl": create_numeric_column("dipl", width=105, valueFormatter={"function": "params.value == null ? '' : params.value.toFixed(1) + '%'"}, filterParams={"defaultOption": "inRange"}),
+    "econ": create_numeric_column("econ", width=105, valueFormatter={"function": "params.value == null ? '' : params.value.toFixed(1) + '%'"}, filterParams={"defaultOption": "inRange"}),
+    "scty": create_numeric_column("scty", width=105, valueFormatter={"function": "params.value == null ? '' : params.value.toFixed(1) + '%'"}, filterParams={"defaultOption": "inRange"}),
+    **{
+        col: create_numeric_column(
+            col,
+            headerComponentParams={"template": template_with_split_header.format(high=col.split('-')[0], low=col.split('-')[1])},
+            width=175,
+            valueFormatter={"function": "params.value == null ? '' : params.value.toFixed(1) + '%'"},
+            cellClass="border-left" if i == 0 else "",
+            filterParams={"defaultOption": "inRange"}
+        ) for i, col in enumerate(COLUMN_GROUPS["politics_axes_group"])
     },
-    {
-        "field": "Test Date",
-        "width": 130,
-        "filter": "agDateColumnFilter",
-        "filterParams": {
-            "defaultOption": "greaterThan",
-            "browserDatePicker": True,
-            "inRangeInclusive": True
-        },
-        "filterValueGetter": {
-            "function": """
-                function(params) {
-                    if (!params.data['Test Date']) return null;
-                    const [year, month, day] = params.data['Test Date'].split('-');
-                    return new Date(year, month - 1, day);
-                }
-            """
-        },
-        "valueFormatter": {
-            "function": """
-                function(params) {
-                    if (!params.value) return '';
-                    const [year, month, day] = params.value.split('-');
-                    return `${month}/${day}/${year}`;
-                }
-            """
-        },
-        "cellClass": "ag-left-aligned-cell",
-        "headerClass": "ag-left-aligned-header wrap-text",
-        "wrapHeaderText": True,
-        "autoHeaderHeight": True,
-        "sortable": True
-    }
-])
+
+    # --- Other Toggles ---
+    "Prompt Template": create_text_column("Prompt Template", width=160, filterParams={"defaultOption": "contains"}),
+    "Architecture": create_text_column("Architecture", width=160, filterParams={"defaultOption": "contains"}),
+    "Avg Thinking Chars": create_numeric_column("Avg Thinking Chars", width=120, filterParams={"defaultOption": "greaterThanOrEqual"}, valueFormatter={"function": "params.value === 0 ? '' : params.value"}),
+}
 
 # Define the grid options with postSort
 dashGridOptions = {
@@ -827,25 +938,62 @@ dashGridOptions = {
     "pinnedTopRowData": [],
     "suppressMaintainUnsortedOrder": True,
     "suppressMultiSort": True,
+    # "maintainColumnOrder": True,
     "rowBuffer": 10,
     "maxBlocksInCache": 2,
     "icons": {
         "menu": '<i class="fas fa-search" style="color: var(--text-color)"></i>'
     },
-    "theme": "ag-theme-alpine-dark" if "prefers-color-scheme: dark" else "ag-theme-alpine",
-    "columnState": {
-        "function": """
-            function() {
-                return {
-                    columnVisibility: {}
-                };
-            }
-        """
-    }
+    "theme": "ag-theme-alpine-dark" if "prefers-color-scheme: dark" else "ag-theme-alpine"
 }
 
+def get_initial_column_defs():
+    """Generates the column definitions for the initial page load."""
+    visible_cols = {"pinned", "is_new", "R", "#P", "type", "Model_Display", "Release Date", "Test Date"}
+    visible_cols.update(PRESET_COLUMNS['Overview'].keys())
+    
+    primary_sort_col = "UGI 🏆"
+    pinned_cols = ["pinned", "is_new", "R", "Avg Thinking Chars", "#P", "type", "Model_Display"]
+
+    initial_defs = []
+    for col_name in MASTER_COLUMN_ORDER:
+        if col_name not in ALL_COLUMN_DEFS:
+            continue
+        
+        # --- START OF MODIFICATION ---
+        if col_name == "Writing ✍️":
+            # Manually create the definition for our test column
+            col_def = {
+                "field": "Writing ✍️",
+                "headerName": "Writing ✍️",
+                "width": 135
+            }
+        else:
+            # Use the existing logic for all other columns
+            col_def = ALL_COLUMN_DEFS[col_name].copy()
+        # --- END OF MODIFICATION ---
+
+        col_def['hide'] = col_name not in visible_cols
+        col_def['pinned'] = 'left' if col_name in pinned_cols else None
+        
+        if col_def.get('field') == primary_sort_col:
+            col_def['sort'] = 'desc'
+            col_def['sortIndex'] = 0
+        
+        initial_defs.append(col_def)
+
+    border_cols = {"UGI 🏆", "NatInt 💡", "Writing ✍️", "Political Lean 📋"}
+    for col_def in initial_defs:
+        if col_def.get('field') in border_cols:
+            current_class = col_def.get('cellClass', '')
+            if 'border-left' not in current_class:
+                col_def['cellClass'] = f"{current_class} border-left".strip()
+                
+    return initial_defs
+
 # Define the layout
 app.layout = html.Div([
+    dcc.Location(id='url', refresh=False),
     dcc.Store(id='pinned-models-store', data=[]),
     
     # Header
@@ -875,127 +1023,117 @@ app.layout = html.Div([
             )
         ], style={'float': 'right'})
     ], style={'overflow': 'hidden', 'marginBottom': '20px', 'padding': '0 20px'}),
-    
-    # Temporary Notice
-    html.Div(
-        html.P(
-            "*Currently working on adding new benchmarks to the leaderboard, so I will probably not test additional models until the new leaderboard is released.",
-            style={'textAlign': 'center', 'color': 'red', 'fontSize': '0.9em'}
-        )
-    ),
-    
-    # Title
-    html.Div([
-        html.H1("📢 UGI Leaderboard", 
-            className="page-title",
-            style={'fontSize': '38px'}),
-        html.H2("Uncensored General Intelligence", 
-            className="page-subtitle"),
-    ], style={'marginBottom': '30px'}),
+
+    html.H1("📢 UGI Leaderboard", className="page-title", style={'fontSize': '38px'}),
+    html.H2("Uncensored General Intelligence", className="page-subtitle"),
 
     html.Div([
-        html.Div([
-            "To filter columns, click the ",
-            html.I(className="fas fa-search", style={"color": "var(--text-color)"}),
-            " next to a column's name. On mobile, hold the column name for the menu to appear."
-        ], style={'marginBottom': '20px', 'color': 'var(--text-color)'})
-    ], style={'padding': '0 20px'}),
-    
-    # Model Type Filter
+        "To filter columns, click the ", html.I(className="fas fa-search"), " icon. On mobile, hold the column name for the menu to appear."
+    ], style={'marginTop': '20px', 'marginBottom': '20px', 'padding': '0 20px'}),
+
+    # --- TOP FILTER SECTION ---
     html.Div([
+        # Left side: Model Type
         html.Div([
-            html.Label("Display Models:", 
-                className="model-type-filter"),
-            dcc.Checklist(
-                id='model-type-filter',
-                options=[
-                    {'label': html.Span('Base', style={'color': '#71de5f', 'fontSize': '16.5px'}), 'value': 'Is Foundation'},
-                    {'label': html.Span('Finetune', style={'color': '#f6b10b', 'fontSize': '16.5px'}), 'value': 'Is Finetuned'},
-                    {'label': html.Span('Merge', style={'color': '#f08aff', 'fontSize': '16.5px'}), 'value': 'Is Merged'},
-                    {'label': html.Span('Proprietary', style={'color': '#19cdce', 'fontSize': '16.5px'}), 'value': 'proprietary'}
+            # The label is now a direct child, so it will appear on its own line above the checklists.
+            html.Label("Display Models:", className="model-type-filter"),
+            
+            # A new sub-container for the interactive elements, using flexbox for horizontal alignment.
+            html.Div(
+                [
+                    # Checklist for the main types
+                    dcc.Checklist(
+                        id='model-type-filter-main',
+                        options=[
+                            {'label': html.Span('Base', style={'color': '#71de5f'}), 'value': 'Is Foundation'},
+                            {'label': html.Span('Finetune', style={'color': '#f6b10b'}), 'value': 'Is Finetuned'},
+                            {'label': html.Span('Merge', style={'color': '#f08aff'}), 'value': 'Is Merged'},
+                            {'label': html.Span('Proprietary', style={'color': '#19cdce'}), 'value': 'proprietary'},
+                        ],
+                        value=['Is Foundation', 'Is Finetuned', 'Is Merged', 'proprietary'],
+                        inline=True,
+                        labelStyle={'fontWeight': 'normal', 'marginRight': '15px'}
+                    ),
+                    
+                    # The visual divider with adjusted margins for balanced spacing.
+                    # It has less left margin to compensate for the right margin of "Proprietary".
+                    html.Span('|', style={
+                        'marginLeft': '-5px', 
+                        'marginRight': '10px', 
+                        'color': 'var(--secondary-text)'
+                    }),
+                    
+                    # Checklist for the reasoning type
+                    dcc.Checklist(
+                        id='model-type-filter-reasoning',
+                        options=[
+                            {'label': html.Span('Reasoning'), 'value': 'Is Thinking Model'}
+                        ],
+                        value=['Is Thinking Model'],
+                        inline=True,
+                    ),
                 ],
-                value=['Is Foundation', 'Is Finetuned', 'Is Merged', 'proprietary'],
-                inline=True,
-                style={'display': 'inline-block'},
-                labelStyle={'fontWeight': 'normal', 'marginRight': '15px'}
+                style={'display': 'flex', 'alignItems': 'center'} # Flexbox applies only to this line
             )
-        ], style={'float': 'left'}),
-        html.Div([
-            dcc.Checklist(
-                id='na-model-filter',
-                options=[{'label': 'NA Models', 'value': 'show_na'}],
-                value=[],
-                inline=True,
-                style={'display': 'inline-block'},
-                labelStyle={'fontWeight': 'normal'}  # Make sure NA Models isn't bold
-            )
-        ], style={'float': 'right'})
-    ], style={'marginBottom': '10px', 'padding': '0 20px', 'overflow': 'hidden'}),
-    
-    # Additional Columns Filter
-    html.Div([
+        ]),
+        # Right side: Other Options
         html.Div([
-            html.Label("Show Additional Columns:", 
-                className="model-type-filter"),
+            html.Label("Other Options:", className="model-type-filter"),
             dcc.Checklist(
-                id='additional-columns-filter',
-                options=[
-                    {'label': 'UGI Categories', 'value': 'ugi_categories'},
-                    {'label': 'W/10 Types', 'value': 'w10_types'},
-                    {'label': 'Political Test Axes', 'value': 'political_axes'}
-                ],
+                id='other-toggles-checklist',
+                options=[{'label': label, 'value': col} for col, label in OTHER_TOGGLES.items()] +
+                        [{'label': 'NA Models', 'value': 'show_na'}],
                 value=[],
                 inline=True,
-                style={'display': 'inline-block'},
                 labelStyle={'fontWeight': 'normal', 'marginRight': '15px'}
             )
-        ], style={'float': 'left'}),
-        html.Div([
-            dcc.Checklist(
-                id='template-filter',
-                options=[{'label': 'Prompt Template', 'value': 'template'}],
-                value=[],
-                inline=True,
-                style={'display': 'inline-block'},
-                labelStyle={'fontWeight': 'normal'}
+        ], style={'textAlign': 'left'}), # Corrected alignment
+    ], style={'display': 'flex', 'flexWrap': 'wrap', 'justifyContent': 'space-between', 'alignItems': 'center', 'padding': '0 20px', 'marginBottom': '20px'}),
+
+
+    # --- HORIZONTAL CONTAINER FOR PRESETS AND CHECKLISTS ---
+    html.Div(
+        [
+            # Create a vertical block for each preset
+            html.Div(
+                [
+                    dcc.RadioItems(
+                        id=f'{preset.lower()}-selector',
+                        className='preset-selector',
+                        options=[{'label': preset, 'value': preset}],
+                        value='Overview' if preset == 'Overview' else None,
+                        inputStyle={"marginRight": "8px"}
+                    ),
+                    dcc.Checklist(
+                        id=f'{preset.lower()}-checklist',
+                        className='preset-checklist',
+                        options=PRESET_OPTIONS[preset],
+                        value=[],
+                        labelStyle={'display': 'block', 'marginBottom': '8px', 'fontWeight': 'normal'}
+                    ) if preset != "Overview" else None
+                ],
+                className='preset-column',
+                id=f'{preset.lower()}-preset-div'
             )
-        ], style={'float': 'right'})
-    ], style={'marginBottom': '13px', 'padding': '0 20px', 'overflow': 'hidden'}),
-    
+            for preset in PRESET_COLUMNS.keys()
+        ],
+        className='preset-container',
+        style={'padding': '0 20px', 'marginBottom': '20px'}
+    ),
+
     # Grid
     html.Div([
         dag.AgGrid(
             id='leaderboard-grid',
-            columnDefs=columnDefs,
             rowData=df.to_dict('records'),
+            columnDefs=get_initial_column_defs(),
             defaultColDef={
-                "sortable": True,
-                "resizable": True,
-                "filter": "agNumberColumnFilter",
-                "floatingFilter": False,
+                "sortable": True, "resizable": True, "filter": True, "floatingFilter": False,
+                "suppressMovable": True,  # This disables column dragging for all columns
                 "sortingOrder": ['desc', 'asc'],
                 "filterParams": {
                     "defaultOption": "between"
                 },
-                "comparator": {
-                    "function": """
-                        function(valueA, valueB, nodeA, nodeB, isInverted) {
-                            const isEmptyA = valueA === null || valueA === undefined || valueA === '' || isNaN(valueA);
-                            const isEmptyB = valueB === null || valueB === undefined || valueB === '' || isNaN(valueB);
-                            
-                            // Force empty values to bottom
-                            if (isEmptyA && !isEmptyB) return 1;
-                            if (!isEmptyA && isEmptyB) return -1;
-                            if (isEmptyA && isEmptyB) return 0;
-                            
-                            // Normal comparison for non-empty values
-                            if (typeof valueA === 'number' && typeof valueB === 'number') {
-                                return valueA - valueB;
-                            }
-                            return String(valueA).localeCompare(String(valueB));
-                        }
-                    """
-                }
             },
             dashGridOptions=dashGridOptions,
             dangerously_allow_code=True,
@@ -1006,231 +1144,414 @@ app.layout = html.Div([
         )
     ], style={'marginBottom': '30px'}),
     
+    # html.Div([
+    #     html.H4("Debug Information"),
+    #     html.Pre(id='debug-output', style={'border': '1px solid #ccc', 'padding': '10px', 'whiteSpace': 'pre-wrap', 'maxHeight': '400px', 'overflowY': 'auto'})
+    # ]),
+    
     # Description
     html.Div([
-        html.H3("About", style={'fontSize': '22px', 'marginBottom': '0px'}),
-        
-        html.P([html.Strong("UGI:"), " Uncensored General Intelligence. A benchmark measuring both willingness to answer and accuracy in fact-based contentious questions. The test set is made of roughly 100 questions/tasks, covering topics that are commonly difficult to get LLMs to answer. The leaderboard's questions are kept private in order to avoid the common problem of not knowing if a model is intelligent or if it was just trained on the test questions."], 
-            style={'marginTop': '7px', 'marginBottom': '4px'}),
-        
+        html.H3("About the Benchmarks", style={'fontSize': '22px', 'marginBottom': '10px'}),
+        html.P(
+            "To ensure a fair evaluation, all test questions are kept private. This prevents models from being specifically trained on the benchmark itself."
+        ),
+
+        # --- Uncensored Section ---
+        html.P([html.Strong("UGI 🏆"), ": Uncensored General Intelligence"], style={'marginTop': '20px', 'fontSize': '1.2em'}),
+        html.P("Measures a model's knowledge of sensitive topics and its ability to follow instructions when faced with controversial prompts."),
         html.Details([
-            html.Summary("Categories", 
-                style={
-                    'fontWeight': 'normal', 
-                    'fontSize': '1em', 
-                    'marginLeft': '20px',
-                    'cursor': 'pointer'
-                }),
+            html.Summary("UGI Metrics", style={'fontWeight': 'normal', 'fontSize': '1em', 'marginLeft': '20px', 'cursor': 'pointer'}),
             html.Ul([
-                html.Li("Unruly: Taboo underground knowledge and recipes"),
-                html.Li("Internet: Knowledge of controversial/explicit web content"),
-                html.Li("Societal/Political: Awareness of contentious socio-political topics")
-            ], style={'marginTop': '0px', 'marginBottom': '16px', 'marginLeft': '40px'})
-        ], style={'marginBottom': '16px'}),
-        
-        html.P([html.Strong("W/10:"), " Willingness/10. A more narrow subset of the UGI questions, solely focused on measuring how far a model can be pushed before going against its instructions or refusing to answer."], style={'marginBottom': '4px'}),
-        
+                html.Li([html.Strong("Categories:")]),
+                html.Ul([
+                    html.Li([html.Strong("Hazardous:"), " Knowledge of topics that LLMs probably shouldn't assist with."]),
+                    html.Li([html.Strong("Entertainment:"), " Knowledge of adult or controversial entertainment and media."]),
+                    html.Li([html.Strong("SocPol:"), " Knowledge of sensitive socio-political topics."]),
+                ], style={'listStyleType': 'circle', 'marginLeft': '20px'}),
+                html.Li([html.Strong("W/10 👍 (Willingness/10):"), " A component of the UGI score that measures how far a model can be pushed before it refuses to answer or deviates from instructions."]),
+                html.Ul([
+                    html.Li([html.Strong("W/10-Direct:"), " Measures if the model directly refuses to respond to certain prompts."]),
+                    html.Li([html.Strong("W/10-Adherence:"), " Measures if a model deviates from instructions, which can be a form of refusal or a sign of lower intelligence."]),
+                ], style={'listStyleType': 'circle', 'marginLeft': '20px'}),
+            ], style={'marginTop': '5px', 'marginLeft': '40px'})
+        ], open=True),
+
+        # --- Intelligence Section ---
+        html.P([html.Strong("NatInt 💡"), ": Natural Intelligence"], style={'marginTop': '20px', 'fontSize': '1.2em'}),
+        html.P("Measures a model's general knowledge and reasoning capabilities across a range of standard and specialized domains."),
         html.Details([
-            html.Summary("Types", 
-                style={
-                    'fontWeight': 'normal', 
-                    'fontSize': '1em', 
-                    'marginLeft': '20px',
-                    'cursor': 'pointer'
-                }),
+            html.Summary("Intelligence Metrics", style={'fontWeight': 'normal', 'fontSize': '1em', 'marginLeft': '20px', 'cursor': 'pointer'}),
             html.Ul([
-                html.Li("Direct: Measures if the model directly refuses to respond to certain prompts"),
-                html.Li("Adherence: Some models might not explicitly refuse to do something, though will still deviate from the instructions as a way of getting out of doing it, or simply due to lack of instruction following capabilities")
-            ], style={'marginTop': '0px', 'marginBottom': '16px', 'marginLeft': '40px'})
-        ], style={'marginBottom': '16px'}),
-        
-        html.P([
-            "A high UGI but low W/10 could mean for example that the model can provide a lot of accurate sensitive information, but will refuse to form the information into something it sees as offensive or against its rules.",
-            html.Br(),
-            html.Br()
-        ]),
-        
-        html.P([
-            html.Strong("Benchmarks not focused on censorship:"),
-            html.Div(style={'margin': '6px 0'}),
-            html.Strong("NatInt:"), " Natural Intelligence. A general knowledge quiz covering real-world subjects that llms are not commonly benchmarked on, such as pop culture trivia. This measures if the model understands a diverse range of topics, as opposed to over-training on textbook information and the types of questions commonly tested on benchmarks."
+                html.Li([html.Strong("Standard:"), " Measures knowledge of standard, factual information like dates, statistics, math, and logic."]),
+                html.Li([html.Strong("Pop Culture:"), " Knowledge of specific details from things like video games, movies, music, and internet culture."]),
+                html.Li([html.Strong("World Model:"), " Tasks that test a model's understanding of real-world properties and patterns."]),
+                html.Ul([
+                    html.Li([html.Strong("Cooking (% Error):"), " Predicts needed ingredient amounts for recipes."]),
+                    html.Li([html.Strong("GeoGuesser (km Error):"), " Identifies a location based on a description of its surroundings."]),
+                    html.Li([html.Strong("Weight (% Error):"), " Estimates the weight of various objects based on their description."]),
+                    html.Li([html.Strong("Music (Error):"), " Predicts a song's musical attributes (like bpm and loudness) based on its lyrics."]),
+                    html.Li([html.Strong("YouTube Views (% Error):"), " Estimates a video's view count from its title, given examples from the same channel."]),
+                    html.Li([html.Strong("Show Recommendation Score:"), " A model's ability to predict what rating out of ten a person will rate a TV show based on their previous ratings."]),
+                    html.Ul([
+                        html.Li([html.Strong("Show Rec MAE:"), " The mean absolute error between the model's predicted ratings and the user's true ratings."]),
+                        html.Li([html.Strong("Show Rec Pearson:"), " Measures how well the model's predictions trend with the user's true ratings."]),
+                        html.Li([html.Strong("Show Rec Std Dev Error:"), " The absolute difference between the spread of the model's predictions and the spread of the true ratings."]),
+                    ], style={'listStyleType': 'circle', 'marginLeft': '20px'}),
+                ], style={'listStyleType': 'circle', 'marginLeft': '20px'}),
+            ], style={'marginTop': '5px', 'marginLeft': '40px'})
+        ], open=True),
+
+        # --- Writing Section ---
+        html.P([html.Strong("Writing ✍️")], style={'marginTop': '20px', 'fontSize': '1.2em'}),
+        html.P("A score of a model's writing ability, factoring in intelligence, writing style, amount of repetition, and adherence to requested output length. The score attempts to match the average person's preferences. Optimal values are displayed in parentheses in the column headers for the metrics used in the formula (e.g., 'Readability Grade (~5.5)'). These values were estimated using human feedback through model preference."),
+        html.Details([
+            html.Summary("Writing Metrics", style={'fontWeight': 'normal', 'fontSize': '1em', 'marginLeft': '20px', 'cursor': 'pointer'}),
+            html.Ul([
+                html.Li([html.Strong("NSFW/Dark Scores:"), " Measures the tonal direction a model takes when writing stories, from SFW to explicit (NSFW) and from lighthearted to violent/tragic (Dark)."]),
+                html.Li([html.Strong("Stylistic Metrics:")]),
+                html.Ul([
+                    html.Li([html.Strong("Readability Grade:"), " The estimated US school grade level needed to understand the text."]),
+                    html.Li([html.Strong("Verb/Noun Ratio:"), " The ratio of action words (verbs) to naming words (nouns)."]),
+                    html.Li([html.Strong("Adj&Adv %:"), " The percentage of descriptive words (adjectives and adverbs) out of total words."]),
+                    html.Li([html.Strong("Dialogue %:"), " The percentage of sentences in the model's response that is dialogue when writing stories."]),
+                ], style={'listStyleType': 'circle', 'marginLeft': '20px'}),
+                html.Li([html.Strong("Repetition Metrics:")]),
+                html.Ul([
+                    html.Li([html.Strong("Lexical Stuckness:"), " Measures if the model gets 'stuck' using a limited vocabulary in parts of its writing."]),
+                    html.Li([html.Strong("Originality:"), " Measures how unique each story is by comparing its word usage and themes against all other stories generated by the same model for different prompts."]),
+                    html.Li([html.Strong("Semantic Redundancy:"), " Detects when the same concept is expressed multiple times with different wording."]),
+                ], style={'listStyleType': 'circle', 'marginLeft': '20px'}),
+                html.Li([html.Strong("Length Adherence:")]),
+                html.Ul([
+                    html.Li([html.Strong("Length Error %:"), " The average percentage difference between a user-requested word count and the generated word count."]),
+                    html.Li([html.Strong("Exceeded %:"), " The percentage of times the model responds with more words than requested."]),
+                ], style={'listStyleType': 'circle', 'marginLeft': '20px'}),
+                html.Li([html.Strong("Style Adherence:"), " How closely the model is able to match the writing style of a given example."]),
+            ], style={'marginTop': '5px', 'marginLeft': '40px'})
+        ], open=True),
+
+        # --- Politics Section ---
+        html.P([html.Strong("Political Lean 📋")], style={'marginTop': '20px', 'fontSize': '1.2em'}),
+        html.Details([
+            html.Summary("Political Metrics", style={'fontWeight': 'normal', 'fontSize': '1em', 'marginLeft': '20px', 'cursor': 'pointer'}),
+            html.Ul([
+                html.Li([html.Strong("Political Lean 📋:"), " Measures a model's political alignment based on its responses to the ", html.A("12axes", href="https://politicaltests.github.io/12axes/", target="_blank", style={'color': 'var(--link-color)'}), " test. The Political Lean metric uses a simplified version with the Assimilationist-Multiculturalist, Collectivize-Privatize, and Progressive-Traditional axes. The score ranges from -100% (Left) to 100% (Right)."]),
+                html.Li([html.Strong("12axes Ideology:"), " The closest matching political ideology from the 12axes test."]),
+                html.Li([html.Strong("Aggregate Scores:")]),
+                html.Ul([
+                    html.Li("Govt: Higher = State authority, Lower = Individual liberty"),
+                    html.Li("Dipl: Higher = Global outlook, Lower = National interests"),
+                    html.Li("Econ: Higher = Economic equality, Lower = Market freedom"),
+                    html.Li("Scty: Higher = Progressive values, Lower = Traditional values")
+                ], style={'listStyleType': 'circle', 'marginLeft': '20px'}),
+            ], style={'marginTop': '5px', 'marginLeft': '40px'})
+        ], open=True),
+        html.Details([
+            html.Summary("12axes Ideology Descriptions", style={'fontWeight': 'normal', 'fontSize': '1em', 'marginLeft': '20px', 'cursor': 'pointer', 'marginTop': '10px'}),
+            html.Div([
+                html.I("Only showing ideologies at least one model has.", className='ideology-note', style={'fontSize': '0.9em'}),
+                dcc.Markdown("\n\n".join([
+                    f"**{ideology}**: {IDEOLOGY_DESCRIPTIONS.get(ideology, 'No description available.')}"
+                    for ideology in sorted(set(df['12axes Ideology'].dropna()))
+                    if ideology
+                ]), className='markdown-content'),
+                html.Div([
+                    html.A("Source", href="https://github.com/politicaltests/politicaltests.github.io/blob/main/12axes/ideologies.js", target="_blank", className="source-link")
+                ], style={'marginTop': '20px'})
+            ], style={'paddingTop': '10px', 'marginLeft': '40px'})
         ]),
-        
-        html.P([html.Strong("Coding:"), " A simple 50 question quiz measuring how vast a model's programming knowledge is. Each question is worth 2 points."]),
-        
-        html.P([
-            html.Strong("Political Lean:"), 
-            " Measures a model's tendency to hold left wing vs right wing political beliefs. Ranges between -100% and 100%, where left wing is left of zero (negative) and right wing is right of zero (positive). Uses the axes of the ",
-            html.A("12axes", 
-                href="https://politicaltests.github.io/12axes/", 
-                target="_blank",
-                style={'color': 'var(--link-color)'}
-            ),
-            " test most aligned with modern left vs right issues: Assimilationist-Multiculturalist, Collectivize-Privatize, and Progressive-Traditional. To see all of the axis scores, select the option above the leaderboard to show all Political Test Axes."
-        ], style={'marginBottom': '4px'}),
-        html.Ul([
-            html.Li("NA if model wasn't capable of answering a sufficient number of questions.")
-        ], style={'marginTop': '0px', 'marginBottom': '16px'}),
-        
-        html.P("Aggregate Political Scores", style={'marginBottom': '4px'}),
-        html.Ul([
-            html.Li("Govt: Higher = State authority, Lower = Individual liberty"),
-            html.Li("Dipl: Higher = Global outlook, Lower = National interests"),
-            html.Li("Econ: Higher = Economic equality, Lower = Market freedom"),
-            html.Li("Scty: Higher = Progressive values, Lower = Traditional values")
-        ], style={'marginTop': '0px', 'marginBottom': '16px'}),
-        
-        html.Br(),
-        
-        html.P("All local models are tested using Q6_K.gguf quants.")
+
     ], style={
         'maxWidth': '1200px',
         'margin': '0 auto',
         'padding': '0 20px',
-        'color': 'var(--text-color)'
+        'color': 'var(--text-color)',
+        'marginBottom': '80px'
     }),
     
-    # Add 12axes Ideology Descriptions here
-    html.Details([
-        html.Summary("12axes Ideology Descriptions", 
-            className="details-summary"),
-        html.Div([
-            html.I("Only showing ideologies at least one model has.", 
-                className='ideology-note',
-                style={'fontSize': '0.9em'}),
-            dcc.Markdown("\n\n".join([
-                f"**{ideology}**: {IDEOLOGY_DESCRIPTIONS.get(ideology, 'No description available.')}"
-                for ideology in sorted(set(df['Ideology Name'].dropna()))
-                if ideology  # Skip empty values
-            ]), className='markdown-content'),
-            html.Div([
-                html.A("Source", 
-                    href="https://github.com/politicaltests/politicaltests.github.io/blob/main/12axes/ideologies.js",
-                    target="_blank",
-                    className="source-link")
-            ], style={'marginTop': '20px'})
-        ], style={'paddingTop': '10px'})
-    ], style={'marginTop': '30px', 'marginBottom': '50px', 'maxWidth': '1200px', 'margin': '30px auto 80px'})
 ], style={'maxWidth': '100%', 'margin': '0 auto'})
 
+OVERVIEW_MAPPING = {
+    "Uncensored": ["UGI 🏆", "W/10 👍"],
+    "Intelligence": ["NatInt 💡"],
+    "Writing": ["Writing ✍️"],
+    "Politics": ["Political Lean 📋"]
+}
+
 @app.callback(
-    [Output('leaderboard-grid', 'rowData'),
-     Output('model-type-filter', 'value'),
-     Output('pinned-models-store', 'data')],
-    [Input('model-type-filter', 'value'),
-     Input('na-model-filter', 'value'),
-     Input('leaderboard-grid', 'pinnedTopRowData')],
+    [Output(f'{p.lower()}-checklist', 'value') for p in PRESET_COLUMNS.keys() if p != "Overview"] +
+    [Output(f'{p.lower()}-selector', 'value') for p in PRESET_COLUMNS.keys()],
+    [Input(f'{p.lower()}-selector', 'value') for p in PRESET_COLUMNS.keys()],
     prevent_initial_call=False
 )
-def update_grid(selected_types, show_na, pinned_rows):
-    if selected_types is None:
-        selected_types = []
-        
-    if not selected_types:
-        return [], selected_types, []
-
-    filtered_df = df.copy()
-    
-    # Get pinned model IDs
-    pinned_models = []
-    if pinned_rows:
-        pinned_models = [row['Model_Display'] for row in pinned_rows]
-        # Remove pinned models from the dataframe
-        filtered_df = filtered_df[~filtered_df['Model_Display'].isin(pinned_models)]
-
-    mask = pd.Series(False, index=filtered_df.index)
+def sync_presets_and_checklists(*selector_values):
+    ctx = dash.callback_context
+    if not ctx.triggered_id:
+        selected_preset = "Overview"
+    else:
+        triggering_id_root = ctx.triggered_id.split('.')[0]
+        selected_preset = triggering_id_root.replace('-selector', '').capitalize()
     
-    # Model type filtering
-    if 'Is Finetuned' in selected_types:
-        if 'Is Merged' in selected_types:
-            mask |= filtered_df['Is Finetuned']
-        else:
-            mask |= (filtered_df['Is Finetuned'] & ~filtered_df['Is Merged'])
-    elif 'Is Merged' in selected_types:
-        mask |= filtered_df['Is Merged']
-        
-    if 'Is Foundation' in selected_types:
-        mask |= (filtered_df['Is Foundation'] & ~filtered_df['Total Parameters'].isna())
-    if 'proprietary' in selected_types:
-        mask |= filtered_df['Total Parameters'].isna()
-    
-    filtered_df = filtered_df[mask]
-    
-    # NA filtering
-    political_columns = ['Political Lean 📋', 'govt', 'dipl', 'econ', 'scty'] + AXES_COLS_2
-    has_na = filtered_df[political_columns].isna().any(axis=1)
-    
-    if show_na is None or not show_na:
-        filtered_df = filtered_df[~has_na]
-    
-    # Use the same multi-key sorting as in load_leaderboard_data
-    filtered_df = filtered_df.sort_values(
-        by=['UGI 🏆', 'NatInt 💡', 'Release_Date_Sort'], 
-        ascending=[False, False, True]  # UGI desc, NatInt desc, Release date asc (earliest first)
-    )
+    checklist_outputs = {p: [] for p in PRESET_COLUMNS.keys() if p != "Overview"}
+    selector_outputs = {p: None for p in PRESET_COLUMNS.keys()}
+
+    if selected_preset == "Overview":
+        for preset, cols in OVERVIEW_MAPPING.items():
+            checklist_outputs[preset] = cols
+    # Simplified this logic since the special case is gone.
+    elif selected_preset == "Intelligence":
+        checklist_outputs["Intelligence"] = list(PRESET_COLUMNS["Intelligence"].keys())
+    elif selected_preset == "Writing":
+        checklist_outputs["Writing"] = list(PRESET_COLUMNS["Writing"].keys())
+        checklist_outputs["Intelligence"] = ["NatInt 💡"]
+    elif selected_preset in checklist_outputs:
+        checklist_outputs[selected_preset] = list(PRESET_COLUMNS[selected_preset].keys())
+
+    selector_outputs[selected_preset] = selected_preset
     
-    records = filtered_df.to_dict('records')
+    final_checklist_values = [checklist_outputs[p] for p in PRESET_COLUMNS.keys() if p != "Overview"]
+    final_selector_values = [selector_outputs[p] for p in PRESET_COLUMNS.keys()]
     
-    return records, selected_types, pinned_models
+    return final_checklist_values + final_selector_values
 
 @app.callback(
-    Output('leaderboard-grid', 'columnDefs'),
-    [Input('additional-columns-filter', 'value'),
-     Input('template-filter', 'value')]
+    Output('leaderboard-grid', 'columnDefs', allow_duplicate=True),
+    [Input(f'{p.lower()}-checklist', 'value') for p in PRESET_COLUMNS.keys() if p != "Overview"] +
+    [Input('other-toggles-checklist', 'value')] +
+    [Input(f'{p.lower()}-selector', 'value') for p in PRESET_COLUMNS.keys()],
+    prevent_initial_call=True
 )
-def update_columns(additional_columns, template_filter):
-    # Start with base columns up to UGI column
-    current_columns = columnDefs[:6]  # Include up to Model column
-    
-    # Add Template column if selected
-    if template_filter and 'template' in template_filter:
-        current_columns.append(template_column)
-    
-    # Rest of the function remains the same...
-    current_columns.extend(columnDefs[6:7])
-    
-    if 'ugi_categories' in additional_columns:
-        current_columns.extend(ugi_category_columns)
+def update_columns_and_sort(uncensored_cols, intelligence_cols, writing_cols, politics_cols, other_toggles, *selector_values):
+    ctx = dash.callback_context
     
-    current_columns.extend(columnDefs[7:8])
-    
-    if 'w10_types' in additional_columns:
-        current_columns.extend(w10_type_columns)
+    apply_default_sort = False
+    if ctx.triggered_id and ctx.triggered_id.endswith('-selector'):
+        apply_default_sort = True
+
+    active_preset = 'Overview'
+    for i, preset_name in enumerate(PRESET_COLUMNS.keys()):
+        if selector_values[i] == preset_name:
+            active_preset = preset_name
+            break
+            
+    all_selections = set(uncensored_cols + intelligence_cols + writing_cols + politics_cols + other_toggles)
+        
+    expanded_selections = set()
+    for item in all_selections:
+        if item in COLUMN_GROUPS:
+            expanded_selections.update(COLUMN_GROUPS[item])
+        else:
+            expanded_selections.add(item)
+            
+    visible_cols = {"pinned", "is_new", "R", "#P", "type", "Model_Display", "Release Date", "Test Date"}
+    visible_cols.update(expanded_selections)
     
-    current_columns.extend(columnDefs[8:11])
+    sort_map = {
+        "Overview": "UGI 🏆",
+        "Uncensored": "UGI 🏆",
+        "Intelligence": "NatInt 💡",
+        "Writing": "Writing ✍️",
+        "Politics": None
+    }
+    primary_sort_col = sort_map.get(active_preset)
+    pinned_cols = ["pinned", "is_new", "R", "Avg Thinking Chars", "#P", "type", "Model_Display"]
+
+    # --- FINAL CORRECTED LOGIC ---
     
-    if 'political_axes' in additional_columns:
-        current_columns.extend(political_columns)
-        current_columns.extend([col for col in columnDefs if col['field'] in AXES_COLS_1])
-        current_columns.extend([col for col in columnDefs if col['field'] in AXES_COLS_2])
+    final_defs = []
+    for col_name in MASTER_COLUMN_ORDER:
+        if col_name not in ALL_COLUMN_DEFS:
+            continue
+            
+        col_def = ALL_COLUMN_DEFS[col_name].copy()
+        
+        # THIS IS THE LINE THAT HAS BEEN REMOVED.
+        # col_def.pop('headerComponentParams', None) 
+        
+        col_def['hide'] = col_name not in visible_cols
+        col_def['pinned'] = 'left' if col_name in pinned_cols else None
+        
+        if apply_default_sort:
+            if col_def.get('field') == primary_sort_col:
+                col_def['sort'] = 'desc'
+                col_def['sortIndex'] = 0
+            else:
+                col_def['sort'] = None
+                col_def['sortIndex'] = None
+        
+        final_defs.append(col_def)
+
+    if active_preset == 'Writing':
+        natint_col_def = next((col for col in final_defs if col.get('field') == 'NatInt 💡'), None)
+        
+        if natint_col_def:
+            temp_defs = [col for col in final_defs if col.get('field') != 'NatInt 💡']
+            try:
+                insert_index = next(i for i, col in enumerate(temp_defs) if col.get('field') == 'Writing ✍️') + 1
+                temp_defs.insert(insert_index, natint_col_def)
+                final_defs = temp_defs
+            except StopIteration:
+                pass
+
+    # --- Logic for adding optimal values via CSS classes (unchanged and correct) ---
+    WRITING_OPTIMAL_CLASSES = {
+        "avg_length_error_pct": "header-optimal-len-err",
+        "NatInt 💡": "header-optimal-natint",
+        "originality_score": "header-optimal-orig",
+        "internal_semantic_redundancy": "header-optimal-sem-red",
+        "lexical_stuckness": "header-optimal-lex-stuck",
+        "Adjective_Adverb_Percentage": "header-optimal-adj-adv",
+        "Readability_Grade_Level": "header-optimal-read-grade",
+        "Dialogue_Percentage": "header-optimal-dialogue"
+    }
+
+    for col_def in final_defs:
+        # Clear any previous optimal classes first
+        current_classes = col_def.get('headerClass', '').split()
+        cleaned_classes = [c for c in current_classes if not c.startswith('header-optimal-')]
+        col_def['headerClass'] = ' '.join(cleaned_classes)
+
+        if active_preset == 'Writing':
+            field = col_def.get('field')
+            if field in WRITING_OPTIMAL_CLASSES:
+                class_to_add = WRITING_OPTIMAL_CLASSES[field]
+                current_classes = col_def.get('headerClass', '').split()
+                if class_to_add not in current_classes:
+                    current_classes.append(class_to_add)
+                    col_def['headerClass'] = ' '.join(current_classes)
+
+    # --- Border logic (unchanged) ---
+    border_cols = set()
+    if active_preset == 'Overview':
+        border_cols = {"UGI 🏆", "NatInt 💡", "Writing ✍️", "Political Lean 📋"}
+    elif active_preset == 'Uncensored':
+        border_cols = {"UGI 🏆", "W/10 👍"}
+    elif active_preset == 'Intelligence':
+         border_cols = {"NatInt 💡"}
+    elif active_preset == 'Writing':
+        border_cols = {"Writing ✍️", "NatInt 💡"}
+    else:
+        main_score_columns = ["UGI 🏆", "W/10 👍", "NatInt 💡", "Writing ✍️", "Political Lean 📋"]
+        for col_def in final_defs:
+            if not col_def.get('hide', True) and col_def.get('field') in main_score_columns:
+                border_cols.add(col_def.get('field'))
+                break
+
+    for col_def in final_defs:
+        if col_def.get('field') in border_cols:
+            current_class = col_def.get('cellClass', '')
+            if 'border-left' not in current_class:
+                col_def['cellClass'] = f"{current_class} border-left".strip()
+                
+    return final_defs
     
-    current_columns.extend([col for col in columnDefs if col['field'] in ['Release Date', 'Test Date']])
+@app.callback(
+    Output('leaderboard-grid', 'rowData'),
+    [Input(f'{p.lower()}-selector', 'value') for p in PRESET_COLUMNS.keys()] +
+    [Input(f'{p.lower()}-checklist', 'value') for p in PRESET_COLUMNS.keys() if p != "Overview"] +
+    [
+        Input('model-type-filter-main', 'value'),
+        Input('model-type-filter-reasoning', 'value'),
+        Input('other-toggles-checklist', 'value')
+    ]
+)
+def update_grid_rows(*args):
+    # 1. Unpack arguments
+    num_presets = len(PRESET_COLUMNS)
+    num_checklists = num_presets - 1
+
+    selector_values = args[:num_presets]
+    checklist_values = args[num_presets : num_presets + num_checklists]
+    main_types = args[num_presets + num_checklists]
+    reasoning_type = args[num_presets + num_checklists + 1]
+    other_toggles = args[num_presets + num_checklists + 2]
+
+    uncensored_cols, intelligence_cols, writing_cols, politics_cols = checklist_values
+
+    # 2. Basic setup
+    selected_types = main_types + reasoning_type
+    show_na_filter = 'show_na' in other_toggles
+    filtered_df = df.copy()
+
+    # 3. Model Type Filtering (unchanged)
+    categories = {
+        'Is Foundation': (filtered_df['Is Foundation'] & ~filtered_df['Is Merged'] & pd.notna(filtered_df['Total Parameters'])),
+        'Is Finetuned': (filtered_df['Is Finetuned'] & ~filtered_df['Is Merged']),
+        'Is Merged': filtered_df['Is Merged'],
+        'proprietary': pd.isna(filtered_df['Total Parameters']),
+        'Is Thinking Model': filtered_df['Is Thinking Model']
+    }
+    final_mask = pd.Series(True, index=filtered_df.index)
+    for category_value, condition_mask in categories.items():
+        if category_value not in selected_types:
+            final_mask &= ~condition_mask
+    filtered_df = filtered_df[final_mask]
+
+    # 4. Determine active preset
+    active_preset = None
+    for i, preset_name in enumerate(PRESET_COLUMNS.keys()):
+        if selector_values[i] == preset_name:
+            active_preset = preset_name
+            break
+
+    # 5. Apply preset-specific filtering for Writing preset
+    if active_preset == 'Writing' and not show_na_filter:
+        filtered_df.dropna(subset=['Writing ✍️'], inplace=True)
+
+    # 6. Apply context-aware "NA Models" filter
+    if show_na_filter:
+        all_selections = set(uncensored_cols + intelligence_cols + writing_cols + politics_cols)
+        if active_preset == 'Overview':
+             all_selections.update(PRESET_COLUMNS['Overview'].keys())
+
+        is_writing_visible = 'Writing ✍️' in all_selections
+        is_politics_visible = 'Political Lean 📋' in all_selections
+        # Now correctly checks if the "World Model Tests" checkbox is ticked
+        is_pred_reasoning_visible = 'world_model_group' in intelligence_cols
+        
+        na_conditions = []
+        if is_writing_visible:
+            na_conditions.append(filtered_df['Writing ✍️'].isna())
+        if is_pred_reasoning_visible:
+            na_conditions.append(filtered_df['Show Rec Score'] == -99999)
+        if is_politics_visible:
+            na_conditions.append(filtered_df['Political Lean 📋'].isna())
+
+        if na_conditions:
+            final_na_mask = pd.Series(False, index=filtered_df.index)
+            for condition in na_conditions:
+                final_na_mask |= condition
+            filtered_df = filtered_df[final_na_mask]
+        else:
+            filtered_df = filtered_df.iloc[0:0]
+
+    return filtered_df.to_dict('records')
     
-    return current_columns
+app.clientside_callback(
+    """
+    function(_, columnDefs) {
+        // This function runs once on page load to set the initial pinning based on screen size.
+        const isMobile = window.innerWidth < 800;
+        if (!isMobile || !columnDefs) {
+            // On desktop, or if defs are not ready, do nothing.
+            return dash_clientside.no_update;
+        }
+        
+        // On mobile, create a new set of definitions with all pinning removed.
+        const newDefs = columnDefs.map(col => {
+            const newCol = Object.assign({}, col);
+            newCol.pinned = null; // Un-pin the column
+            return newCol;
+        });
+        return newDefs;
+    }
+    """,
+    Output('leaderboard-grid', 'columnDefs', allow_duplicate=True),
+    Input('url', 'pathname'),
+    State('leaderboard-grid', 'columnDefs'),
+    prevent_initial_call=True
+)
 
     
 if __name__ == '__main__':
-    app.run_server(host='0.0.0.0', port=8050)
-    app.clientside_callback(
-        """
-        function(n_clicks) {
-            if (!window.gridApi) return;
-            
-            const pinnedRows = window.gridApi.getGridOption('pinnedTopRowData') || [];
-            
-            if (pinnedRows.length > 0) {
-                const pinnedIds = new Set(pinnedRows.map(row => row.Model_Display));
-                const currentRows = [];
-                window.gridApi.forEachNode(node => {
-                    if (!pinnedIds.has(node.data.Model_Display)) {
-                        currentRows.push(node.data);
-                    }
-                });
-                window.gridApi.setGridOption('rowData', currentRows);
-            }
-            return window.dash_clientside.no_update;
-        }
-        """,
-        Output('leaderboard-grid', 'rowData'),
-        Input('model-type-filter', 'value')
-    )
+    app.run_server(host='0.0.0.0', port=8050)