Runtime Version and QLBM Upload Option

em/simulation.py

@@ -5,6 +5,9 @@ Contains simulation logic including run_simulation_only, reset_to_defaults,
 and stop handlers.
 """
 import re
+import asyncio
+import threading
+import time
 import numpy as np
 
 from .state import state, ctrl, _apply_workflow_highlights, is_statevector_estimator_selected, is_ibm_qpu_selected
@@ -36,6 +39,77 @@ except ModuleNotFoundError:
     )
     import utils.delta_impulse_generator as qutils
 
+# --- Module-level async infrastructure ---
+_heartbeat_thread = None
+_heartbeat_on = False
+_sim_start_time = None
+_simulation_executor = None  # Thread pool for async execution
+_main_loop = None  # Reference to main event loop for thread-safe callbacks
+
+def _get_server():
+    """Get the trame server from state module."""
+    from .state import get_server
+    return get_server()
+
+def _flush_state():
+    """Force state flush to browser (synchronous, for main thread use)."""
+    try:
+        server = _get_server()
+        if server:
+            server.state.flush()
+    except Exception:
+        pass
+
+def _flush_state_threadsafe():
+    """
+    Thread-safe state flush - schedules flush on the main event loop.
+    Use this from background threads (e.g., inside executor callbacks).
+    """
+    global _main_loop
+    try:
+        server = _get_server()
+        if server and _main_loop is not None and _main_loop.is_running():
+            # Schedule the flush on the main event loop
+            _main_loop.call_soon_threadsafe(server.state.flush)
+        elif server:
+            # Fallback: direct flush (may not work from threads)
+            server.state.flush()
+    except Exception:
+        pass
+
+async def _flush_async():
+    """Async helper to flush state and yield to event loop."""
+    _flush_state()
+    await asyncio.sleep(0)  # Yield control to event loop
+
+def _start_progress_heartbeat():
+    """Start background thread for continuous progress updates."""
+    global _heartbeat_thread, _heartbeat_on, _sim_start_time
+    
+    if _heartbeat_thread and _heartbeat_thread.is_alive():
+        return
+    
+    _sim_start_time = time.time()
+    
+    def loop_fn():
+        global _heartbeat_on
+        while _heartbeat_on:
+            if state.is_running and _sim_start_time is not None:
+                elapsed = time.time() - _sim_start_time
+                state.simulation_elapsed = elapsed
+                _flush_state_threadsafe()  # Use thread-safe version
+            time.sleep(0.1)  # Update every 100ms
+    
+    _heartbeat_on = True
+    _heartbeat_thread = threading.Thread(target=loop_fn, daemon=True)
+    _heartbeat_thread.start()
+
+def _stop_progress_heartbeat():
+    """Stop the background heartbeat thread."""
+    global _heartbeat_on, _heartbeat_thread
+    _heartbeat_on = False
+    _heartbeat_thread = None
+
 __all__ = [
     "run_simulation_only",
     "reset_to_defaults",
@@ -239,11 +313,42 @@ def redraw_surface_plot():
     ctrl.view_update()
 
 
+# ---------------------------------------------------------------------------
+# Async Simulation Runner with Full Async Pattern
+# ---------------------------------------------------------------------------
+
 def run_simulation_only():
-    """Run the simulation based on current state settings."""
+    """
+    Entry point for simulation - launches the async worker.
+    This is called by the UI button click and schedules the async task.
+    """
+    server = _get_server()
+    if server is None:
+        log_to_console("Error: Server not available")
+        return
+    
+    # Schedule the async simulation
+    asyncio.ensure_future(_run_simulation_async())
+
+
+async def _run_simulation_async():
+    """
+    Async simulation runner that uses thread pool for blocking work.
+    This allows the UI to update in real-time during simulation.
+    """
+    global _main_loop
+    
     from . import globals as g
     from .excitation import nearest_node_index
     from .qpu import build_qpu_timeseries_plotly_multi
+    from concurrent.futures import ThreadPoolExecutor
+    
+    # Capture the main event loop for thread-safe callbacks
+    _main_loop = asyncio.get_event_loop()
+    
+    # Create executor for blocking operations
+    executor = ThreadPoolExecutor(max_workers=1)
+    loop = _main_loop
     
     # Require selections before running
     if not state.geometry_selection:
@@ -255,6 +360,7 @@ def run_simulation_only():
         state.show_progress = False
         state.is_running = False
         state.run_button_text = "RUN!"
+        await _flush_async()
         return
     
     if not state.dist_type:
@@ -266,6 +372,7 @@ def run_simulation_only():
         state.show_progress = False
         state.is_running = False
         state.run_button_text = "RUN!"
+        await _flush_async()
         return
     
     # Show status: Starting simulation
@@ -275,13 +382,20 @@ def run_simulation_only():
     state.status_type = "info"
     state.show_progress = True
     state.simulation_progress = 0
+    await _flush_async()
+    
+    # Start heartbeat for continuous elapsed time updates
+    _start_progress_heartbeat()
     
+    # Progress callback that updates state (called from worker thread)
+    # Uses thread-safe flush to push updates to browser
     last_logged_percent = [0]
     def _progress_callback(percent):
         state.simulation_progress = percent
         if percent - last_logged_percent[0] >= 10:
             log_to_console(f"Simulation progress: {int(percent)}%")
             last_logged_percent[0] = percent
+        _flush_state_threadsafe()  # Thread-safe flush!
 
     # Reset stop flag and enable Stop button at start
     set_stop_simulation(False)
@@ -293,10 +407,9 @@ def run_simulation_only():
     state.is_running = True
     state.simulation_has_run = False
     state.run_button_text = "Running"
-    try:
-        ctrl.view_update()
-    except Exception:
-        pass
+    
+    # Initial flush to show "Running" state
+    _flush_state()
     
     nx, T = int(state.nx), float(state.T)
     na, R = 1, 4
@@ -304,6 +417,8 @@ def run_simulation_only():
     try:
         state.status_message = "Creating initial state..."
         state.simulation_progress = 10
+        _flush_state()
+        
         if state.dist_type == "Delta":
             initial_state = create_impulse_state_from_pos(
                 (nx, nx), 
@@ -325,6 +440,9 @@ def run_simulation_only():
         state.is_running = False
         state.run_button_text = "RUN!"
         state.stop_button_disabled = True
+        _stop_progress_heartbeat()
+        await _flush_async()
+        executor.shutdown(wait=False)
         return
 
     sve_selected = is_statevector_estimator_selected()
@@ -335,6 +453,8 @@ def run_simulation_only():
             log_to_console("Running Statevector Estimator...")
             state.status_message = "Running Statevector Estimator simulation..."
             state.simulation_progress = 20
+            await _flush_async()
+            
             state.qpu_ts_ready = False
             state.qpu_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
             state.qpu_ts_other_ready = False
@@ -361,6 +481,7 @@ def run_simulation_only():
             
             state.status_message = "Building Statevector Estimator time series..."
             state.simulation_progress = 60
+            await _flush_async()
             
             def _sve_series_runner(field_type, positions, total_time, snapshot_dt, nx, impulse_pos, progress_callback=None, print_callback=None):
                 return qutils.run_sve(
@@ -377,13 +498,16 @@ def run_simulation_only():
                     print_callback=print_callback,
                 )
 
-            # Build and render Plotly chart
-            fig = build_qpu_timeseries_plotly_multi(
-                configs, nx, T, snapshot_dt, impulse_pos,
-                series_runner=_sve_series_runner,
-                progress_callback=_progress_callback, 
-                print_callback=log_to_console
-            )
+            # Run SVE in executor to keep UI responsive
+            def _run_sve_blocking():
+                return build_qpu_timeseries_plotly_multi(
+                    configs, nx, T, snapshot_dt, impulse_pos,
+                    series_runner=_sve_series_runner,
+                    progress_callback=_progress_callback, 
+                    print_callback=log_to_console
+                )
+            
+            fig = await loop.run_in_executor(executor, _run_sve_blocking)
             qpu_ts_cache["fig"] = fig
             
             try:
@@ -425,10 +549,9 @@ def run_simulation_only():
         finally:
             state.is_running = False
             state.stop_button_disabled = True
-            try:
-                ctrl.view_update()
-            except Exception:
-                pass
+            _stop_progress_heartbeat()
+            await _flush_async()
+            executor.shutdown(wait=False)
         return
 
     # IBM QPU branch
@@ -438,10 +561,7 @@ def run_simulation_only():
             log_to_console("Running IBM QPU simulation...")
             state.status_message = "Running IBM QPU simulation..."
             state.simulation_progress = 5
-            state.qpu_ts_ready = False
-            state.qpu_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
-            state.qpu_ts_other_ready = False
-            state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+            await _flush_async()
             
             # Import IBM QPU backend
             try:
@@ -476,34 +596,38 @@ def run_simulation_only():
             
             state.status_message = "Step 1: Circuit Construction & Optimization (0-40%)..."
             state.simulation_progress = 10
+            await _flush_async()
             
             def _ibm_progress_callback(pct):
                 state.simulation_progress = int(pct)
-                # Update status message based on progress stage
                 if pct < 40:
                     state.status_message = f"Step 1: Circuit Construction & Optimization ({int(pct)}%)"
                 elif pct < 90:
                     state.status_message = f"Step 2: Circuit Execution ({int(pct)}%)"
                 else:
                     state.status_message = f"Step 3: Result Processing ({int(pct)}%)"
+                _flush_state_threadsafe()  # Thread-safe flush from callback thread
             
-            # Call the IBM QPU get_field_values function
-            field_values = ibm_get_field_values(
-                field=field_type,
-                x=monitor_x,
-                y=monitor_y,
-                T=float(T),
-                snapshot_time=snapshot_dt,
-                nx=nx,
-                impulse_pos=impulse_pos,
-                shots=10000,
-                pm_optimization_level=2,
-                simulation="False",
-                optimization="True",
-                platform="IBM",
-                progress_callback=_ibm_progress_callback,
-                print_callback=log_to_console,
-            )
+            # Call the IBM QPU get_field_values function in executor to keep UI responsive
+            def _run_ibm_qpu():
+                return ibm_get_field_values(
+                    field=field_type,
+                    x=monitor_x,
+                    y=monitor_y,
+                    T=float(T),
+                    snapshot_time=snapshot_dt,
+                    nx=nx,
+                    impulse_pos=impulse_pos,
+                    shots=10000,
+                    pm_optimization_level=2,
+                    simulation="True",
+                    optimization="True",
+                    platform="IBM",
+                    progress_callback=_ibm_progress_callback,
+                    print_callback=log_to_console,
+                )
+            
+            field_values = await loop.run_in_executor(executor, _run_ibm_qpu)
             
             # Build time frames to match the output
             times = ibm_create_time_frames(float(T), snapshot_dt)
@@ -578,6 +702,7 @@ def run_simulation_only():
             log_to_console("IBM QPU run completed")
             state.status_type = "success"
             state.show_progress = False
+            await _flush_async()  # Update UI with completion status
             
             ready = bool(field_values) and len(field_values) > 0
             state.qpu_ts_ready = ready
@@ -613,10 +738,9 @@ def run_simulation_only():
         finally:
             state.is_running = False
             state.stop_button_disabled = True
-            try:
-                ctrl.view_update()
-            except Exception:
-                pass
+            _stop_progress_heartbeat()
+            executor.shutdown(wait=False)
+            await _flush_async()
         return
 
     # IonQ QPU placeholder branch (not yet implemented)
@@ -629,16 +753,18 @@ def run_simulation_only():
         state.run_button_text = "RUN!"
         state.stop_button_disabled = True
         log_to_console("IonQ QPU backend not connected. Use IBM QPU or Statevector Estimator instead.")
+        await _flush_async()
         try:
             ctrl.view_update()
         except Exception:
             pass
         return
 
-    # Simulator path
+    # Simulator path - run blocking simulation in executor
     log_to_console("Running simulation...")
     state.status_message = "Running simulation... This may take a while."
     state.simulation_progress = 30
+    await _flush_async()
     
     snapshot_dt = float(state.dt_user)
     
@@ -646,19 +772,40 @@ def run_simulation_only():
         return g.stop_simulation
     
     state.simulation_progress = 50
-    sim_data, times = run_sim(
-        nx, na, R, initial_state, T, 
-        snapshot_dt=snapshot_dt, 
-        stop_check=_stop_check, 
-        progress_callback=_progress_callback, 
-        print_callback=log_to_console
-    )
+    await _flush_async()
+    
+    # Run the blocking simulation in a thread pool to keep UI responsive
+    def _run_blocking_sim():
+        return run_sim(
+            nx, na, R, initial_state, T, 
+            snapshot_dt=snapshot_dt, 
+            stop_check=_stop_check, 
+            progress_callback=_progress_callback,
+            print_callback=log_to_console
+        )
+    
+    try:
+        sim_data, times = await loop.run_in_executor(executor, _run_blocking_sim)
+    except Exception as e:
+        state.error_message = f"Simulation error: {e}"
+        state.status_message = f"Error: {e}"
+        state.status_type = "error"
+        state.show_progress = False
+        state.is_running = False
+        state.run_button_text = "RUN!"
+        state.stop_button_disabled = True
+        _stop_progress_heartbeat()
+        await _flush_async()
+        executor.shutdown(wait=False)
+        return
+    
     g.simulation_data = sim_data
     g.snapshot_times = times
     log_to_console("Simulation complete.")
     
     state.simulation_progress = 80
     state.status_message = "Processing simulation results..."
+    await _flush_async()
     
     if sim_data.size > 0:
         setup_surface_plot_data(sim_data, nx)
@@ -678,6 +825,11 @@ def run_simulation_only():
 
     state.is_running = False
     state.stop_button_disabled = True
+    _stop_progress_heartbeat()
+    await _flush_async()
+    
+    # Cleanup executor
+    executor.shutdown(wait=False)
 
 
 def reset_to_defaults():
@@ -1059,4 +1211,4 @@ def update_value_display(point):
             text = f"Index: ({ix}, {iy}) | Position: ({x_code:.3f}, {y_code:.3f})\nValue: {value:.3e}"
 
     plotter.add_text(text, name="value_text", position="lower_left", color="black", font_size=10)
-    ctrl.view_update()
+    ctrl.view_update()

em/utils.py

@@ -120,9 +120,6 @@ def load_logo_data_uri() -> str:
     base_dir = os.path.dirname(os.path.dirname(__file__))  # quantum_embedded folder
     candidates = [
         os.path.join(base_dir, "ansys-part-of-synopsys-logo.svg"),
-        os.path.join(base_dir, "synopsys-logo-color-rgb.svg"),
-        os.path.join(base_dir, "synopsys-logo-color-rgb.png"),
-        os.path.join(base_dir, "synopsys-logo-color-rgb.jpg"),
         # Also check in parent quantum folder
         os.path.join(os.path.dirname(base_dir), "quantum", "ansys-part-of-synopsys-logo.svg"),
     ]

qlbm_embedded.py

@@ -12,6 +12,11 @@ import math
 import pyvista as pv
 import plotly.graph_objects as go
 import tempfile
+import base64
+import json
+import asyncio
+import threading
+import time as time_module
 from pathlib import Path
 from datetime import datetime
 from trame_vuetify.widgets import vuetify3
@@ -25,6 +30,7 @@ pv.OFF_SCREEN = True
 # --- Qiskit Backend Detection ---
 _QISKIT_BACKEND_AVAILABLE = False
 _QISKIT_IMPORT_ERROR = None
+_VISUALIZE_COUNTS_AVAILABLE = False
 
 try:
     from qlbm.qlbm_sample_app import (
@@ -41,6 +47,20 @@ except ImportError as e:
     _QISKIT_IMPORT_ERROR = str(e)
     print(f"Qiskit backend not available: {e}")
 
+# Import visualize_counts for job result processing
+try:
+    from qlbm.visualize_counts import (
+        load_samples,
+        estimate_density,
+        plot_density_isosurface_slider,
+    )
+    _VISUALIZE_COUNTS_AVAILABLE = True
+except ImportError as e:
+    print(f"visualize_counts not available: {e}")
+    load_samples = None
+    estimate_density = None
+    plot_density_isosurface_slider = None
+
 # --- CUDA-Q Backend Detection ---
 def _env_flag(name: str) -> bool:
     return os.environ.get(name, "").strip().lower() in ("1", "true", "yes")
@@ -90,6 +110,69 @@ simulation_data_frames = []
 simulation_times = []
 current_grid_object = None
 
+# --- Async infrastructure for real-time progress updates ---
+_qlbm_main_loop = None  # Reference to main event loop for thread-safe callbacks
+_qlbm_heartbeat_thread = None
+_qlbm_heartbeat_on = False
+_qlbm_sim_start_time = None
+
+def _qlbm_flush_state():
+    """Force state flush to browser (synchronous, for main thread use)."""
+    try:
+        if _server:
+            _server.state.flush()
+    except Exception:
+        pass
+
+def _qlbm_flush_state_threadsafe():
+    """
+    Thread-safe state flush - schedules flush on the main event loop.
+    Use this from background threads (e.g., inside executor callbacks).
+    """
+    global _qlbm_main_loop
+    try:
+        if _server and _qlbm_main_loop is not None and _qlbm_main_loop.is_running():
+            # Schedule the flush on the main event loop
+            _qlbm_main_loop.call_soon_threadsafe(_server.state.flush)
+        elif _server:
+            # Fallback: direct flush (may not work from threads)
+            _server.state.flush()
+    except Exception:
+        pass
+
+async def _qlbm_flush_async():
+    """Async helper to flush state and yield to event loop."""
+    _qlbm_flush_state()
+    await asyncio.sleep(0)  # Yield control to event loop
+
+def _qlbm_start_progress_heartbeat():
+    """Start background thread for continuous progress updates."""
+    global _qlbm_heartbeat_thread, _qlbm_heartbeat_on, _qlbm_sim_start_time
+    
+    if _qlbm_heartbeat_thread and _qlbm_heartbeat_thread.is_alive():
+        return
+    
+    _qlbm_sim_start_time = time_module.time()
+    
+    def loop_fn():
+        global _qlbm_heartbeat_on
+        while _qlbm_heartbeat_on:
+            if _state is not None and _state.qlbm_is_running and _qlbm_sim_start_time is not None:
+                elapsed = time_module.time() - _qlbm_sim_start_time
+                # Optionally update elapsed time state here if needed
+                _qlbm_flush_state_threadsafe()
+            time_module.sleep(0.1)  # Update every 100ms
+    
+    _qlbm_heartbeat_on = True
+    _qlbm_heartbeat_thread = threading.Thread(target=loop_fn, daemon=True)
+    _qlbm_heartbeat_thread.start()
+
+def _qlbm_stop_progress_heartbeat():
+    """Stop the background heartbeat thread."""
+    global _qlbm_heartbeat_on, _qlbm_heartbeat_thread
+    _qlbm_heartbeat_on = False
+    _qlbm_heartbeat_thread = None
+
 GRID_SIZES = [8, 16, 32, 64, 128, 256]
 _WORKFLOW_BASE_STYLE = "font-size: 0.8rem; border: 1px solid transparent; transition: box-shadow 0.2s ease;"
 _WORKFLOW_HIGHLIGHT_STYLE = "font-size: 0.8rem; box-shadow: 0 0 0 2px #6200ea;"
@@ -213,6 +296,18 @@ def init_state():
         "qlbm_qiskit_mode": False,  # True when using Qiskit backend (shows Plotly slider)
         "qlbm_qiskit_backend_available": _QISKIT_BACKEND_AVAILABLE,
         "qlbm_qiskit_fig": None,  # Stores the Plotly figure for Qiskit results
+        
+        # Job upload state (for loading previously saved QPU job results)
+        "qlbm_job_upload": None,  # File upload content
+        "qlbm_job_upload_filename": "",  # Display the uploaded filename
+        "qlbm_job_upload_error": "",  # Error message for upload
+        "qlbm_job_upload_success": "",  # Success message for upload
+        "qlbm_job_platform": "IBM",  # Platform: "IBM" or "IonQ"
+        "qlbm_job_total_time": 3,  # Total time T (generates T_list = [1..T])
+        "qlbm_job_output_resolution": 40,  # Grid resolution for density estimation
+        "qlbm_job_is_processing": False,  # True when processing uploaded job
+        "qlbm_job_flag_qubits": True,  # Whether flag qubits were used
+        "qlbm_job_midcircuit_meas": True,  # Whether mid-circuit measurement was used (IBM only)
     })
     _initialized = True
 
@@ -1077,10 +1172,231 @@ def _run_qiskit_simulation(progress_callback=None):
     return output, fig, params["T_list"]
 
 
+# --- Job Result Upload Processing ---
+def process_uploaded_job_result():
+    """
+    Process an uploaded IBM/IonQ job result JSON file and generate the Plotly figure.
+    
+    This function:
+    1. Decodes the uploaded file (base64 -> JSON)
+    2. Parses the job result based on platform (IBM uses RuntimeDecoder, IonQ uses plain dict)
+    3. Calls load_samples/estimate_density for each timestep
+    4. Generates the slider figure using plot_density_isosurface_slider
+    """
+    global simulation_data_frames, simulation_times, current_grid_object
+    
+    if _state is None:
+        return
+    
+    # Validate required imports
+    if not _VISUALIZE_COUNTS_AVAILABLE:
+        _state.qlbm_job_upload_error = "visualize_counts module not available. Cannot process job results."
+        log_to_console("Error: visualize_counts module not available")
+        return
+    
+    # Validate file upload
+    uploaded = _state.qlbm_job_upload
+    if not uploaded:
+        _state.qlbm_job_upload_error = "No file uploaded. Please select a JSON file."
+        return
+    
+    # Reset messages
+    _state.qlbm_job_upload_error = ""
+    _state.qlbm_job_upload_success = ""
+    _state.qlbm_job_is_processing = True
+    log_to_console("Processing uploaded job result...")
+    
+    try:
+        # Handle list or single file
+        file_data = uploaded[0] if isinstance(uploaded, list) else uploaded
+        
+        # Get filename for display
+        filename = file_data.get("name", "unknown.json") if isinstance(file_data, dict) else "unknown.json"
+        _state.qlbm_job_upload_filename = filename
+        log_to_console(f"Processing file: {filename}")
+        
+        # Decode base64 content
+        content = file_data.get("content", "") if isinstance(file_data, dict) else ""
+        if content.startswith("data:"):
+            content = content.split(",", 1)[1]  # Remove data URI prefix
+        
+        raw_bytes = base64.b64decode(content)
+        json_str = raw_bytes.decode("utf-8")
+        
+        # Parse timesteps from user input
+        # User provides Total Time T, we generate T_list = [1, 2, ..., T]
+        try:
+            total_time = int(_state.qlbm_job_total_time or 3)
+            if total_time < 1:
+                total_time = 1
+            T_list = list(range(1, total_time + 1))
+        except ValueError:
+            _state.qlbm_job_upload_error = "Invalid Total Time. Please enter a positive integer."
+            _state.qlbm_job_is_processing = False
+            return
+        
+        log_to_console(f"Timesteps to process: {T_list}")
+        
+        # Get processing parameters
+        platform = _state.qlbm_job_platform or "IBM"
+        output_resolution = int(_state.qlbm_job_output_resolution or 40)
+        # Defaulting to True as per user request, and hiding from UI
+        flag_qubits = True
+        midcircuit_meas = True
+        
+        log_to_console(f"Platform: {platform}, Resolution: {output_resolution}, Flag qubits: {flag_qubits}")
+        
+        # Parse JSON based on platform
+        if platform == "IBM":
+            # IBM uses RuntimeDecoder for proper result parsing
+            try:
+                from qiskit_ibm_runtime import RuntimeDecoder
+                result = json.loads(json_str, cls=RuntimeDecoder)
+                log_to_console("Parsed IBM result with RuntimeDecoder")
+            except ImportError:
+                # Fallback to plain JSON if RuntimeDecoder not available
+                result = json.loads(json_str)
+                log_to_console("Warning: RuntimeDecoder not available, using plain JSON")
+            except Exception as e:
+                # Try plain JSON as fallback
+                result = json.loads(json_str)
+                log_to_console(f"RuntimeDecoder failed ({e}), using plain JSON")
+        else:
+            # IonQ uses plain JSON
+            result = json.loads(json_str)
+            log_to_console("Parsed IonQ result as plain JSON")
+        
+        # Process each timestep
+        output = []
+        
+        # Determine how to extract counts based on result structure
+        if platform == "IBM":
+            # IBM PrimitiveResult structure: result is a list of PubResults
+            # Each PubResult has .join_data().get_counts()
+            if hasattr(result, '__iter__') and not isinstance(result, dict):
+                for i, (T_total, pub) in enumerate(zip(T_list, result)):
+                    try:
+                        # Try the PrimitiveResult API
+                        if hasattr(pub, 'join_data'):
+                            joined = pub.join_data()
+                            counts = joined.get_counts()
+                        elif hasattr(pub, 'data'):
+                            # Older API
+                            counts = pub.data.get_counts() if hasattr(pub.data, 'get_counts') else dict(pub.data)
+                        elif isinstance(pub, dict):
+                            counts = pub
+                        else:
+                            counts = dict(pub)
+                        
+                        log_to_console(f"Processing timestep T={T_total}: {len(counts)} unique bitstrings")
+                        pts, cnts = load_samples(counts, T_total, logger=log_to_console, 
+                                                 flag_qubits=flag_qubits, midcircuit_meas=midcircuit_meas)
+                        output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
+                    except Exception as e:
+                        log_to_console(f"Error processing timestep {i}: {e}")
+            elif isinstance(result, dict):
+                # Single result or counts dict directly
+                if 'counts' in result:
+                    counts = result['counts']
+                else:
+                    counts = result
+                for T_total in T_list:
+                    log_to_console(f"Processing timestep T={T_total}")
+                    pts, cnts = load_samples(counts, T_total, logger=log_to_console,
+                                             flag_qubits=flag_qubits, midcircuit_meas=midcircuit_meas)
+                    output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
+        else:
+            # IonQ result structure: use get_counts(i) or direct counts dict
+            if hasattr(result, 'get_counts'):
+                for i, T_total in enumerate(T_list):
+                    try:
+                        counts = result.get_counts(i)
+                        log_to_console(f"Processing timestep T={T_total}: {len(counts)} unique bitstrings")
+                        pts, cnts = load_samples(counts, T_total, logger=log_to_console,
+                                                 flag_qubits=flag_qubits, midcircuit_meas=False)
+                        output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
+                    except Exception as e:
+                        log_to_console(f"Error processing timestep {i}: {e}")
+            elif isinstance(result, list):
+                # List of counts dicts
+                for i, (T_total, counts) in enumerate(zip(T_list, result)):
+                    if isinstance(counts, dict):
+                        log_to_console(f"Processing timestep T={T_total}")
+                        pts, cnts = load_samples(counts, T_total, logger=log_to_console,
+                                                 flag_qubits=flag_qubits, midcircuit_meas=False)
+                        output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
+            elif isinstance(result, dict):
+                # Single counts dict
+                counts = result.get('counts', result)
+                for T_total in T_list:
+                    log_to_console(f"Processing timestep T={T_total}")
+                    pts, cnts = load_samples(counts, T_total, logger=log_to_console,
+                                             flag_qubits=flag_qubits, midcircuit_meas=False)
+                    output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
+        
+        if not output:
+            _state.qlbm_job_upload_error = "No valid data extracted from job result. Check timesteps and file format."
+            _state.qlbm_job_is_processing = False
+            return
+        
+        log_to_console(f"Processed {len(output)} timestep(s) successfully")
+        
+        # Generate the Plotly figure
+        fig = plot_density_isosurface_slider(output, T_list)
+        
+        # Update state to show results
+        _state.qlbm_qiskit_mode = True
+        _state.qlbm_qiskit_fig = fig
+        _state.qlbm_simulation_has_run = True
+        _state.qlbm_job_upload_success = f"✓ Successfully processed {len(output)} timestep(s) from {filename}"
+        
+        # Update the Plotly figure widget
+        if hasattr(_ctrl, "qlbm_qiskit_plot_update"):
+            _ctrl.qlbm_qiskit_plot_update(fig)
+        
+        log_to_console(f"Results ready! {len(output)} frames generated.")
+        
+    except json.JSONDecodeError as e:
+        _state.qlbm_job_upload_error = f"Invalid JSON file: {e}"
+        log_to_console(f"JSON decode error: {e}")
+    except Exception as e:
+        _state.qlbm_job_upload_error = f"Error processing job result: {e}"
+        log_to_console(f"Processing error: {e}")
+        import traceback
+        log_to_console(traceback.format_exc())
+    finally:
+        _state.qlbm_job_is_processing = False
+
+
 # --- Main Simulation ---
 def run_simulation():
-    """Run the QLBM simulation."""
-    global simulation_data_frames, simulation_times, current_grid_object, _plotter
+    """
+    Entry point for simulation - launches the async worker.
+    This is called by the UI button click and schedules the async task.
+    """
+    if _server is None:
+        log_to_console("Error: Server not available")
+        return
+    
+    # Schedule the async simulation
+    asyncio.ensure_future(_run_simulation_async())
+
+
+async def _run_simulation_async():
+    """
+    Async simulation runner that uses thread pool for blocking work.
+    This allows the UI to update in real-time during simulation.
+    """
+    global simulation_data_frames, simulation_times, current_grid_object, _plotter, _qlbm_main_loop
+    
+    from concurrent.futures import ThreadPoolExecutor
+    
+    # Capture the main event loop for thread-safe callbacks
+    _qlbm_main_loop = asyncio.get_event_loop()
+    
+    # Create executor for blocking operations
+    executor = ThreadPoolExecutor(max_workers=1)
+    loop = _qlbm_main_loop
     
     if not _SIMULATION_CAN_RUN:
         msg = _SIMULATION_DISABLED_REASON or "Simulation backend is not available on this platform."
@@ -1088,6 +1404,8 @@ def run_simulation():
         log_to_console(f"Error: {msg}")
         _state.qlbm_status_message = "Error: Backend unavailable"
         _state.qlbm_status_type = "error"
+        await _qlbm_flush_async()
+        executor.shutdown(wait=False)
         return
 
     _state.qlbm_is_running = True
@@ -1096,8 +1414,12 @@ def run_simulation():
     _state.qlbm_qiskit_mode = False  # Reset Qiskit mode
     _state.qlbm_show_progress = True
     _state.qlbm_simulation_progress = 0
-    _state.qlbm_status_message = "Running simulation..."
+    _state.qlbm_status_message = "Initializing simulation..."
     _state.qlbm_status_type = "info"
+    await _qlbm_flush_async()
+    
+    # Start heartbeat for continuous progress updates
+    _qlbm_start_progress_heartbeat()
     
     # Determine if using Qiskit backend
     use_qiskit = (
@@ -1126,21 +1448,27 @@ def run_simulation():
     log_to_console("Job Initiated")
     log_to_console(f"Grid Size: {_state.qlbm_grid_size}×{_state.qlbm_grid_size}×{_state.qlbm_grid_size}, Time Steps: {_state.qlbm_time_steps}, Distribution: {_state.qlbm_dist_type}, Boundary: {_state.qlbm_boundary_condition}, Backend: {backend_info}, Velocity: vx={_state.qlbm_vx_expr}, vy={_state.qlbm_vy_expr}, vz={_state.qlbm_vz_expr}")
     
-    last_logged_percent = 0
+    # Progress callback that uses thread-safe flush for real-time updates
+    last_logged_percent = [0]  # Use list for nonlocal in nested function
     def _progress_callback(percent):
-        nonlocal last_logged_percent
         _state.qlbm_simulation_progress = percent
-        if percent - last_logged_percent >= 10:
+        if percent - last_logged_percent[0] >= 10:
             log_to_console(f"Simulation progress: {int(percent)}%")
-            last_logged_percent = percent
+            last_logged_percent[0] = percent
+        _qlbm_flush_state_threadsafe()  # Thread-safe flush!
     
     try:
         # === Qiskit Backend (IBM Qiskit Simulator) ===
         if use_qiskit:
             log_to_console("Using IBM Qiskit Simulator backend...")
+            _state.qlbm_status_message = "Running Qiskit Aer simulation..."
+            await _qlbm_flush_async()
+            
+            # Run Qiskit simulation in executor to keep UI responsive
+            def _run_qiskit_blocking():
+                return _run_qiskit_simulation(progress_callback=_progress_callback)
             
-            # Run Qiskit simulation
-            output, plotly_fig, T_list = _run_qiskit_simulation(progress_callback=_progress_callback)
+            output, plotly_fig, T_list = await loop.run_in_executor(executor, _run_qiskit_blocking)
             
             # Store results
             simulation_data_frames = output
@@ -1156,14 +1484,17 @@ def run_simulation():
             _state.qlbm_simulation_has_run = True
             _state.qlbm_qiskit_mode = True  # Use Plotly display instead of PyVista
             
-            _progress_callback(100)
+            _state.qlbm_simulation_progress = 100
             log_to_console("Qiskit simulation completed successfully.")
             _state.qlbm_status_message = "Simulation completed successfully."
             _state.qlbm_status_type = "success"
+            await _qlbm_flush_async()
 
         # === IBM QPU Backend ===
         elif use_ibm_qpu:
             log_to_console("Using IBM QPU backend...")
+            _state.qlbm_status_message = "Preparing IBM QPU job..."
+            await _qlbm_flush_async()
             
             params = _map_state_to_qiskit_params()
             if params is None:
@@ -1171,6 +1502,9 @@ def run_simulation():
 
             # Create initial state circuit
             log_to_console("Creating initial state circuit...")
+            _state.qlbm_simulation_progress = 10
+            await _qlbm_flush_async()
+            
             init_state_prep_circ = get_named_init_state_circuit(
                 n=params["n"],
                 init_state_name=params["init_state_name"],
@@ -1187,24 +1521,37 @@ def run_simulation():
             )
 
             log_to_console("Submitting job to IBM Quantum...")
+            _state.qlbm_status_message = "Submitting job to IBM Quantum..."
+            _state.qlbm_simulation_progress = 20
+            await _qlbm_flush_async()
             
-            # Run HW simulation
-            job, get_result = run_sampling_hw_ibm(
-                n=params["n"],
-                ux=params["vx_expr"],
-                uy=params["vy_expr"],
-                uz=params["vz_expr"],
-                init_state_prep_circ=init_state_prep_circ,
-                T_list=params["T_list"],
-                # shots=2**14, # Reduced shots for responsiveness/quota
-                shots=2**14,
-                vel_resolution=min(params['grid_size'], 32),
-                output_resolution=min(2*params['grid_size'], 40),
-                logger=log_to_console
-            )
+            # Run HW simulation in executor
+            def _run_ibm_qpu_blocking():
+                log_to_console("Submitting and running IBM QPU job...")
+                job, get_result = run_sampling_hw_ibm(
+                    n=params["n"],
+                    ux=params["vx_expr"],
+                    uy=params["vy_expr"],
+                    uz=params["vz_expr"],
+                    init_state_prep_circ=init_state_prep_circ,
+                    T_list=params["T_list"],
+                    shots=2**14,
+                    vel_resolution=min(params['grid_size'], 32),
+                    output_resolution=min(2*params['grid_size'], 40),
+                    logger=log_to_console
+                )
+                log_to_console("Waiting for job results (this may take time)...")
+                output, plotly_fig = get_result(job)
+                return output, plotly_fig, init_state_prep_circ
             
-            log_to_console("Waiting for job results (this may take time)...")
-            output, plotly_fig = get_result(job)
+            _state.qlbm_status_message = "Waiting for IBM QPU results..."
+            _state.qlbm_simulation_progress = 40
+            await _qlbm_flush_async()
+            
+            output, plotly_fig, init_state_prep_circ = await loop.run_in_executor(executor, _run_ibm_qpu_blocking)
+            
+            _state.qlbm_simulation_progress = 80
+            await _qlbm_flush_async()
             
             # Generate T=0 initial snapshot and prepend to output
             log_to_console("Generating T=0 initial distribution snapshot...")
@@ -1240,6 +1587,10 @@ def run_simulation():
                 log_to_console(f"Warning: Could not generate T=0 snapshot: {exc}")
                 extended_T_list = params["T_list"]
             
+            # Store results
+            simulation_data_frames = output
+            simulation_times = [float(t) for t in extended_T_list]
+            
             # Update UI
             if hasattr(_ctrl, "qlbm_qiskit_result_update"):
                 _ctrl.qlbm_qiskit_result_update(plotly_fig)
@@ -1250,14 +1601,17 @@ def run_simulation():
             _state.qlbm_simulation_has_run = True
             _state.qlbm_qiskit_mode = True
             
-            _progress_callback(100)
+            _state.qlbm_simulation_progress = 100
             log_to_console("IBM QPU simulation completed successfully.")
             _state.qlbm_status_message = "Simulation completed successfully."
             _state.qlbm_status_type = "success"
+            await _qlbm_flush_async()
         
         # === IonQ QPU Backend ===
         elif use_ionq_qpu:
             log_to_console("Using IonQ QPU backend...")
+            _state.qlbm_status_message = "Preparing IonQ QPU job..."
+            await _qlbm_flush_async()
             
             params = _map_state_to_qiskit_params()
             if params is None:
@@ -1265,6 +1619,9 @@ def run_simulation():
 
             # Create initial state circuit
             log_to_console("Creating initial state circuit...")
+            _state.qlbm_simulation_progress = 10
+            await _qlbm_flush_async()
+            
             init_state_prep_circ = get_named_init_state_circuit(
                 n=params["n"],
                 init_state_name=params["init_state_name"],
@@ -1281,23 +1638,37 @@ def run_simulation():
             )
 
             log_to_console("Submitting job to IonQ Quantum...")
+            _state.qlbm_status_message = "Submitting job to IonQ Quantum..."
+            _state.qlbm_simulation_progress = 20
+            await _qlbm_flush_async()
             
-            # Run IonQ HW simulation
-            job, get_result = run_sampling_hw_ionq(
-                n=params["n"],
-                ux=params["vx_expr"],
-                uy=params["vy_expr"],
-                uz=params["vz_expr"],
-                init_state_prep_circ=init_state_prep_circ,
-                T_list=params["T_list"],
-                shots=2**14,
-                vel_resolution=min(params['grid_size'], 32),
-                output_resolution=min(2*params['grid_size'], 40),
-                logger=log_to_console
-            )
+            # Run IonQ HW simulation in executor
+            def _run_ionq_qpu_blocking():
+                log_to_console("Submitting and running IonQ QPU job...")
+                job, get_result = run_sampling_hw_ionq(
+                    n=params["n"],
+                    ux=params["vx_expr"],
+                    uy=params["vy_expr"],
+                    uz=params["vz_expr"],
+                    init_state_prep_circ=init_state_prep_circ,
+                    T_list=params["T_list"],
+                    shots=2**14,
+                    vel_resolution=min(params['grid_size'], 32),
+                    output_resolution=min(2*params['grid_size'], 40),
+                    logger=log_to_console
+                )
+                log_to_console("Waiting for IonQ job results (this may take time)...")
+                output, plotly_fig = get_result(job)
+                return output, plotly_fig, init_state_prep_circ
+            
+            _state.qlbm_status_message = "Waiting for IonQ QPU results..."
+            _state.qlbm_simulation_progress = 40
+            await _qlbm_flush_async()
             
-            log_to_console("Waiting for IonQ job results (this may take time)...")
-            output, plotly_fig = get_result(job)
+            output, plotly_fig, init_state_prep_circ = await loop.run_in_executor(executor, _run_ionq_qpu_blocking)
+            
+            _state.qlbm_simulation_progress = 80
+            await _qlbm_flush_async()
             
             # Generate T=0 initial snapshot and prepend to output
             log_to_console("Generating T=0 initial distribution snapshot...")
@@ -1333,6 +1704,10 @@ def run_simulation():
                 log_to_console(f"Warning: Could not generate T=0 snapshot: {exc}")
                 extended_T_list = params["T_list"]
             
+            # Store results
+            simulation_data_frames = output
+            simulation_times = [float(t) for t in extended_T_list]
+            
             # Update UI
             if hasattr(_ctrl, "qlbm_qiskit_result_update"):
                 _ctrl.qlbm_qiskit_result_update(plotly_fig)
@@ -1343,14 +1718,17 @@ def run_simulation():
             _state.qlbm_simulation_has_run = True
             _state.qlbm_qiskit_mode = True
             
-            _progress_callback(100)
+            _state.qlbm_simulation_progress = 100
             log_to_console("IonQ QPU simulation completed successfully.")
             _state.qlbm_status_message = "Simulation completed successfully."
             _state.qlbm_status_type = "success"
+            await _qlbm_flush_async()
         
         # === CUDA-Q Backend ===
         elif _state.qlbm_backend_type == "Simulator" and _state.qlbm_selected_simulator == "CUDA-Q simulator":
             _state.qlbm_qiskit_mode = False  # Use PyVista display
+            _state.qlbm_status_message = "Running CUDA-Q simulation..."
+            await _qlbm_flush_async()
             
             grid_size = int(_state.qlbm_grid_size)
             num_reg_qubits = int(math.log2(grid_size)) if grid_size > 0 else 3
@@ -1362,37 +1740,49 @@ def run_simulation():
             vy_func = make_velocity_func(_state.qlbm_vy_expr)
             vz_func = make_velocity_func(_state.qlbm_vz_expr)
             
-            _progress_callback(0)
+            _state.qlbm_simulation_progress = 5
+            await _qlbm_flush_async()
             
             if simulate_qlbm_3D_and_animate is not None:
                 log_to_console("Running CUDA-Q Simulation...")
-                _plotter.clear()
-                _, frames, times, grid_obj = simulate_qlbm_3D_and_animate(
-                    num_reg_qubits=num_reg_qubits,
-                    T=T,
-                    distribution_type=distribution_type,
-                    vx_input=vx_func,
-                    vy_input=vy_func,
-                    vz_input=vz_func,
-                    boundary_condition=boundary_condition,
-                    plotter=_plotter,
-                    add_slider=False,
-                    progress_callback=_progress_callback
-                )
+                
+                # Run CUDA-Q simulation in executor
+                def _run_cudaq_blocking():
+                    _plotter.clear()
+                    return simulate_qlbm_3D_and_animate(
+                        num_reg_qubits=num_reg_qubits,
+                        T=T,
+                        distribution_type=distribution_type,
+                        vx_input=vx_func,
+                        vy_input=vy_func,
+                        vz_input=vz_func,
+                        boundary_condition=boundary_condition,
+                        plotter=_plotter,
+                        add_slider=False,
+                        progress_callback=_progress_callback
+                    )
+                
+                result = await loop.run_in_executor(executor, _run_cudaq_blocking)
+                _, frames, times, grid_obj = result
             else:
                 # Fallback to CPU demo if CUDA-Q not available
                 log_to_console("CUDA-Q not available, falling back to CPU Demo...")
-                frames, times, grid_obj = _run_cpu_demo_simulation(
-                    grid_size=grid_size,
-                    T=T,
-                    distribution_type=distribution_type or "Sinusoidal",
-                    vx_func=vx_func,
-                    vy_func=vy_func,
-                    vz_func=vz_func,
-                    progress_callback=_progress_callback
-                )
+                
+                def _run_cpu_demo_blocking():
+                    return _run_cpu_demo_simulation(
+                        grid_size=grid_size,
+                        T=T,
+                        distribution_type=distribution_type or "Sinusoidal",
+                        vx_func=vx_func,
+                        vy_func=vy_func,
+                        vz_func=vz_func,
+                        progress_callback=_progress_callback
+                    )
+                
+                frames, times, grid_obj = await loop.run_in_executor(executor, _run_cpu_demo_blocking)
             
-            _progress_callback(100)
+            _state.qlbm_simulation_progress = 95
+            await _qlbm_flush_async()
             
             # Update plotter with results
             if grid_obj:
@@ -1421,15 +1811,19 @@ def run_simulation():
                 _state.qlbm_status_message = "Simulation completed successfully."
                 _state.qlbm_status_type = "success"
                 _state.qlbm_simulation_progress = 100
+                await _qlbm_flush_async()
             else:
                 _state.qlbm_run_error = "Simulation produced no data."
                 log_to_console("Error: Simulation produced no data.")
                 _state.qlbm_status_message = "Error: No data produced"
                 _state.qlbm_status_type = "error"
+                await _qlbm_flush_async()
         
         # === CPU Demo Backend (for QPU or fallback) ===
         else:
             _state.qlbm_qiskit_mode = False  # Use PyVista display
+            _state.qlbm_status_message = "Running CPU Demo simulation..."
+            await _qlbm_flush_async()
             
             grid_size = int(_state.qlbm_grid_size)
             num_reg_qubits = int(math.log2(grid_size)) if grid_size > 0 else 3
@@ -1443,19 +1837,27 @@ def run_simulation():
             
             _progress_callback(0)
             
-            # CPU Demo Simulation
+            _state.qlbm_simulation_progress = 5
+            await _qlbm_flush_async()
+            
+            # CPU Demo Simulation in executor
             log_to_console("Running CPU Demo Simulation...")
-            frames, times, grid_obj = _run_cpu_demo_simulation(
-                grid_size=grid_size,
-                T=T,
-                distribution_type=distribution_type or "Sinusoidal",
-                vx_func=vx_func,
-                vy_func=vy_func,
-                vz_func=vz_func,
-                progress_callback=_progress_callback
-            )
             
-            _progress_callback(100)
+            def _run_cpu_demo_fallback():
+                return _run_cpu_demo_simulation(
+                    grid_size=grid_size,
+                    T=T,
+                    distribution_type=distribution_type or "Sinusoidal",
+                    vx_func=vx_func,
+                    vy_func=vy_func,
+                    vz_func=vz_func,
+                    progress_callback=_progress_callback
+                )
+            
+            frames, times, grid_obj = await loop.run_in_executor(executor, _run_cpu_demo_fallback)
+            
+            _state.qlbm_simulation_progress = 95
+            await _qlbm_flush_async()
             
             # Update plotter with results
             if grid_obj:
@@ -1484,11 +1886,13 @@ def run_simulation():
                 _state.qlbm_status_message = "Simulation completed successfully."
                 _state.qlbm_status_type = "success"
                 _state.qlbm_simulation_progress = 100
+                await _qlbm_flush_async()
             else:
                 _state.qlbm_run_error = "Simulation produced no data."
                 log_to_console("Error: Simulation produced no data.")
                 _state.qlbm_status_message = "Error: No data produced"
                 _state.qlbm_status_type = "error"
+                await _qlbm_flush_async()
 
     except Exception as e:
         _state.qlbm_run_error = f"Simulation failed: {str(e)}"
@@ -1498,10 +1902,14 @@ def run_simulation():
         traceback.print_exc()
         _state.qlbm_status_message = "Simulation failed"
         _state.qlbm_status_type = "error"
+        await _qlbm_flush_async()
     finally:
         _state.qlbm_is_running = False
+        _qlbm_stop_progress_heartbeat()
+        executor.shutdown(wait=False)
         if _state.qlbm_status_type != "success":
             _state.qlbm_show_progress = False
+        await _qlbm_flush_async()
 
 
 def stop_simulation():
@@ -1659,23 +2067,27 @@ def _build_control_panels(plotter):
         with vuetify3.VCardText():
             vuetify3.VDivider(classes="my-2")
             vuetify3.VCardSubtitle("Problems", classes="text-caption font-weight-bold mt-2")
-            vuetify3.VSelect(
-                key="qlbm_overview_problems",
-                label="Select a problem",
-                v_model=("qlbm_problems_selection", None),
-                items=(
-                    "qlbm_qlbm_problems",
-                    [
-                        "Scalar advection-diffusion in a box",
-                        "Laminar flow & heat transfer for a heated body in water.",
-                    ],
-                ),
-                placeholder="Select",
-                density="compact",
-                hide_details=True,
-                color="primary",
-                classes="mb-2"
-            )
+            with vuetify3.VTooltip(location="top"):
+                with vuetify3.Template(v_slot_activator="{ props }"):
+                    vuetify3.VSelect(
+                        v_bind="props",
+                        key="qlbm_overview_problems",
+                        label="Select a problem",
+                        v_model=("qlbm_problems_selection", None),
+                        items=(
+                            "qlbm_qlbm_problems",
+                            [
+                                "Scalar advection-diffusion in a box",
+                                "Laminar flow & heat transfer for a heated body in water.",
+                            ],
+                        ),
+                        placeholder="Select",
+                        density="compact",
+                        hide_details=True,
+                        color="primary",
+                        classes="mb-2"
+                    )
+                html.Span("Select a predefined fluid dynamics problem to solve")
 
     # Geometry card
     with vuetify3.VCard(classes="mb-2"):
@@ -1703,11 +2115,20 @@ def _build_control_panels(plotter):
                 vuetify3.VCardSubtitle("Domain dimensions", classes="text-caption font-weight-bold mb-2")
                 with vuetify3.VRow(dense=True):
                     with vuetify3.VCol():
-                        vuetify3.VTextField(label="Length (L)", v_model=("qlbm_domain_L", 1.0), type="number", step="0.1", density="compact", hide_details=True, color="primary")
+                        with vuetify3.VTooltip(location="top"):
+                            with vuetify3.Template(v_slot_activator="{ props }"):
+                                vuetify3.VTextField(v_bind="props", label="Length (L)", v_model=("qlbm_domain_L", 1.0), type="number", step="0.1", density="compact", hide_details=True, color="primary")
+                            html.Span("Length of the domain along X axis")
                     with vuetify3.VCol():
-                        vuetify3.VTextField(label="Width (W)", v_model=("qlbm_domain_W", 1.0), type="number", step="0.1", density="compact", hide_details=True, color="primary")
+                        with vuetify3.VTooltip(location="top"):
+                            with vuetify3.Template(v_slot_activator="{ props }"):
+                                vuetify3.VTextField(v_bind="props", label="Width (W)", v_model=("qlbm_domain_W", 1.0), type="number", step="0.1", density="compact", hide_details=True, color="primary")
+                            html.Span("Width of the domain along Y axis")
                     with vuetify3.VCol():
-                        vuetify3.VTextField(label="Height (H)", v_model=("qlbm_domain_H", 1.0), type="number", step="0.1", density="compact", hide_details=True, color="primary")
+                        with vuetify3.VTooltip(location="top"):
+                            with vuetify3.Template(v_slot_activator="{ props }"):
+                                vuetify3.VTextField(v_bind="props", label="Height (H)", v_model=("qlbm_domain_H", 1.0), type="number", step="0.1", density="compact", hide_details=True, color="primary")
+                            html.Span("Height of the domain along Z axis")
 
     # Initial Distribution card
     with vuetify3.VCard(classes="mb-2", style=("qlbm_distribution_card_style", _WORKFLOW_BASE_STYLE)):
@@ -1715,13 +2136,17 @@ def _build_control_panels(plotter):
         with vuetify3.VCardText():
             with vuetify3.VRow(classes="d-flex align-center mb-2", no_gutters=True):
                 with vuetify3.VCol(cols="auto", classes="flex-grow-1"):
-                    vuetify3.VSelect(
-                        label="Initial Distribution",
-                        v_model=("qlbm_dist_type", None),
-                        items=("qlbm_dist_modes",),
-                        density="compact",
-                        hide_details=True
-                    )
+                    with vuetify3.VTooltip(location="top"):
+                        with vuetify3.Template(v_slot_activator="{ props }"):
+                            vuetify3.VSelect(
+                                v_bind="props",
+                                label="Initial Distribution",
+                                v_model=("qlbm_dist_type", None),
+                                items=("qlbm_dist_modes",),
+                                density="compact",
+                                hide_details=True
+                            )
+                        html.Span("Select the initial density distribution function")
                 with vuetify3.VCol(cols="auto", classes="ml-2"):
                     with vuetify3.VBtn(
                         icon=True, density="compact", variant="text",
@@ -1734,30 +2159,42 @@ def _build_control_panels(plotter):
         vuetify3.VCardTitle("Sinusoidal Frequencies")
         with vuetify3.VCardText():
             for axis in ['x', 'y', 'z']:
-                vuetify3.VSlider(
-                    label=f"Freq {axis.upper()}", 
-                    v_model=(f"qlbm_sine_k_{axis}", 1.0), 
-                    min=1, max=5, step=1, 
-                    thumb_label="always", density="compact"
-                )
+                with vuetify3.VTooltip(location="top"):
+                    with vuetify3.Template(v_slot_activator="{ props }"):
+                        vuetify3.VSlider(
+                            v_bind="props",
+                            label=f"Freq {axis.upper()}", 
+                            v_model=(f"qlbm_sine_k_{axis}", 1.0), 
+                            min=1, max=5, step=1, 
+                            thumb_label="always", density="compact"
+                        )
+                    html.Span(f"Frequency multiplier for {axis.upper()} axis")
 
     # Gaussian controls
     with vuetify3.VCard(classes="mb-2", v_if="qlbm_custom_dist_params && qlbm_dist_type === 'Gaussian'"):
         vuetify3.VCardTitle("Gaussian Parameters")
         with vuetify3.VCardText():
             for axis in ['x', 'y', 'z']:
-                vuetify3.VSlider(
-                    label=f"Center {axis.upper()}", 
-                    v_model=(f"qlbm_gauss_c{axis}", 16), 
-                    min=0, max=("qlbm_nx", 32), step=1, 
-                    thumb_label="always", density="compact"
-                )
-            vuetify3.VSlider(
-                label="Width (Sigma)", 
-                v_model=("qlbm_gauss_sigma", 6.0), 
-                min=1.0, max=20.0, step=0.5, 
-                thumb_label="always", density="compact"
-            )
+                with vuetify3.VTooltip(location="top"):
+                    with vuetify3.Template(v_slot_activator="{ props }"):
+                        vuetify3.VSlider(
+                            v_bind="props",
+                            label=f"Center {axis.upper()}", 
+                            v_model=(f"qlbm_gauss_c{axis}", 16), 
+                            min=0, max=("qlbm_nx", 32), step=1, 
+                            thumb_label="always", density="compact"
+                        )
+                    html.Span(f"Center position along {axis.upper()} axis")
+            with vuetify3.VTooltip(location="top"):
+                with vuetify3.Template(v_slot_activator="{ props }"):
+                    vuetify3.VSlider(
+                        v_bind="props",
+                        label="Width (Sigma)", 
+                        v_model=("qlbm_gauss_sigma", 6.0), 
+                        min=1.0, max=20.0, step=0.5, 
+                        thumb_label="always", density="compact"
+                    )
+                html.Span("Standard deviation (spread) of the Gaussian")
 
     # Multi-Dirac-Delta controls
     with vuetify3.VCard(classes="mb-2", v_if="qlbm_custom_dist_params && qlbm_dist_type === 'Multi-Dirac-Delta'"):
@@ -1765,19 +2202,26 @@ def _build_control_panels(plotter):
         with vuetify3.VCardText():
             vuetify3.VCardSubtitle("Number of delta peaks per axis = 2^k", classes="text-caption mb-2")
             for axis in ['x', 'y', 'z']:
-                vuetify3.VSlider(
-                    label=f"k_{axis.upper()} (log₂)", 
-                    v_model=(f"qlbm_mdd_k{axis}_log2", 1), 
-                    min=1, max=4, step=1, 
-                    thumb_label="always", density="compact"
-                )
+                with vuetify3.VTooltip(location="top"):
+                    with vuetify3.Template(v_slot_activator="{ props }"):
+                        vuetify3.VSlider(
+                            v_bind="props",
+                            label=f"k_{axis.upper()} (log₂)", 
+                            v_model=(f"qlbm_mdd_k{axis}_log2", 1), 
+                            min=1, max=4, step=1, 
+                            thumb_label="always", density="compact"
+                        )
+                    html.Span(f"Log2 of number of peaks along {axis.upper()}")
 
     # Boundary Conditions
     with vuetify3.VCard(classes="mb-2"):
         vuetify3.VCardTitle("Boundary Conditions", classes="text-subtitle-2 font-weight-bold text-primary")
         with vuetify3.VCardText():
-            vuetify3.VSelect(label="Boundary Condition", v_model=("qlbm_boundary_condition", "Periodic"), 
-                           items=("['Periodic']",), density="compact", hide_details=True, color="primary")
+            with vuetify3.VTooltip(location="top"):
+                with vuetify3.Template(v_slot_activator="{ props }"):
+                    vuetify3.VSelect(v_bind="props", label="Boundary Condition", v_model=("qlbm_boundary_condition", "Periodic"), 
+                                   items=("['Periodic']",), density="compact", hide_details=True, color="primary")
+                html.Span("Select boundary conditions for the simulation domain")
 
     # Advecting Fields
     with vuetify3.VCard(classes="mb-2", style=("qlbm_advect_card_style", _WORKFLOW_BASE_STYLE)):
@@ -1785,15 +2229,19 @@ def _build_control_panels(plotter):
         with vuetify3.VCardText():
             with vuetify3.VRow(classes="d-flex align-center mb-2", no_gutters=True):
                 with vuetify3.VCol(cols="auto", classes="flex-grow-1"):
-                    vuetify3.VSelect(
-                        label="Select Advecting field",
-                        v_model=("qlbm_advecting_field", None),
-                        items=("['Uniform', 'Swirl', 'Shear', 'TGV']",),
-                        density="compact",
-                        hide_details=True,
-                        color="primary",
-                        placeholder="Select",
-                    )
+                    with vuetify3.VTooltip(location="top"):
+                        with vuetify3.Template(v_slot_activator="{ props }"):
+                            vuetify3.VSelect(
+                                v_bind="props",
+                                label="Select Advecting field",
+                                v_model=("qlbm_advecting_field", None),
+                                items=("['Uniform', 'Swirl', 'Shear', 'TGV']",),
+                                density="compact",
+                                hide_details=True,
+                                color="primary",
+                                placeholder="Select",
+                            )
+                        html.Span("Select the velocity field that transports the fluid")
                 with vuetify3.VCol(cols="auto", classes="ml-2"):
                     with vuetify3.VBtn(
                         icon=True, density="compact", variant="text",
@@ -1802,9 +2250,18 @@ def _build_control_panels(plotter):
                         vuetify3.VIcon("mdi-cog", color=("qlbm_show_advect_params ? 'primary' : 'grey'",))
             with vuetify3.VContainer(v_if="qlbm_show_advect_params", classes="pa-0 mt-2"):
                 html.Div("Velocity Components", classes="text-caption mb-1")
-                vuetify3.VTextField(label="Velocity vx", v_model=("qlbm_vx_expr", "0.2"), density="compact", hide_details=True, color="primary", classes="mb-1")
-                vuetify3.VTextField(label="Velocity vy", v_model=("qlbm_vy_expr", "-0.15"), density="compact", hide_details=True, color="primary", classes="mb-1")
-                vuetify3.VTextField(label="Velocity vz", v_model=("qlbm_vz_expr", "0.3"), density="compact", hide_details=True, color="primary")
+                with vuetify3.VTooltip(location="top"):
+                    with vuetify3.Template(v_slot_activator="{ props }"):
+                        vuetify3.VTextField(v_bind="props", label="Velocity vx", v_model=("qlbm_vx_expr", "0.2"), density="compact", hide_details=True, color="primary", classes="mb-1")
+                    html.Span("X-component of velocity field")
+                with vuetify3.VTooltip(location="top"):
+                    with vuetify3.Template(v_slot_activator="{ props }"):
+                        vuetify3.VTextField(v_bind="props", label="Velocity vy", v_model=("qlbm_vy_expr", "-0.15"), density="compact", hide_details=True, color="primary", classes="mb-1")
+                    html.Span("Y-component of velocity field")
+                with vuetify3.VTooltip(location="top"):
+                    with vuetify3.Template(v_slot_activator="{ props }"):
+                        vuetify3.VTextField(v_bind="props", label="Velocity vz", v_model=("qlbm_vz_expr", "0.3"), density="compact", hide_details=True, color="primary")
+                    html.Span("Z-component of velocity field")
 
     # Meshing
     with vuetify3.VCard(classes="mb-2", style=("qlbm_meshing_card_style", _WORKFLOW_BASE_STYLE)):
@@ -1837,8 +2294,11 @@ def _build_control_panels(plotter):
     with vuetify3.VCard(classes="mb-2"):
         vuetify3.VCardTitle("Time", classes="text-subtitle-2 font-weight-bold text-primary")
         with vuetify3.VCardText():
-            vuetify3.VSlider(label="Total Time", v_model=("qlbm_time_steps", 10), min=0, max=30, step=1, 
-                           thumb_label="always", show_ticks="always", color="primary", density="compact", hide_details=True)
+            with vuetify3.VTooltip(location="top"):
+                with vuetify3.Template(v_slot_activator="{ props }"):
+                    vuetify3.VSlider(v_bind="props", label="Total Time", v_model=("qlbm_time_steps", 10), min=0, max=30, step=1, 
+                                   thumb_label="always", show_ticks="always", color="primary", density="compact", hide_details=True)
+                html.Span("Number of time steps to simulate")
             vuetify3.VAlert(v_if="qlbm_time_steps > 100", type="warning", variant="tonal", density="compact", 
                            children=["Warning: High time steps may increase runtime."], classes="mt-2")
 
@@ -1886,13 +2346,33 @@ def _build_control_panels(plotter):
                 children=["⚠️ Grid size > 16 may exceed IBM QPU capacity!"],
                 classes="mt-2"
             )
+
+            # Sinusoidal Warning for IBM QPU
+            vuetify3.VAlert(
+                v_if="qlbm_backend_type === 'QPU' && qlbm_selected_qpu === 'IBM QPU' && qlbm_dist_type === 'Sinusoidal'",
+                type="warning",
+                variant="tonal",
+                density="compact",
+                children=["⚠️ Sinusoidal distribution results in very high circuit depth on IBM QPU!"],
+                classes="mt-2"
+            )
+
+            # IonQ Restriction Warning
+            vuetify3.VAlert(
+                v_if="qlbm_backend_type === 'QPU' && qlbm_selected_qpu === 'IonQ QPU' && qlbm_dist_type !== 'Multi-Dirac-Delta'",
+                type="error",
+                variant="tonal",
+                density="compact",
+                children=["⚠️ IonQ QPU only supports Multi-Dirac-Delta distribution."],
+                classes="mt-2"
+            )
             
             vuetify3.VDivider(classes="my-3")
             vuetify3.VBtn(
                 text="Run",
                 color="primary",
                 block=True,
-                disabled=("qlbm_is_running || !qlbm_backend_type", True),
+                disabled=("qlbm_is_running || !qlbm_backend_type || (qlbm_backend_type === 'QPU' && qlbm_selected_qpu === 'IonQ QPU' && qlbm_dist_type !== 'Multi-Dirac-Delta')", True),
                 click=run_simulation,
                 style=("qlbm_is_running ? '' : 'background-color:#87CEFA;'", ""),
             )
@@ -1925,6 +2405,108 @@ def _build_control_panels(plotter):
                         click=stop_simulation,
                         disabled=("!qlbm_is_running", True),
                     )
+            
+            # --- Job Result Upload Section ---
+            vuetify3.VDivider(classes="my-3")
+            html.Div("Upload Job Results", classes="text-subtitle-2 font-weight-bold text-primary mb-2")
+            html.Div("Load previously saved IBM/IonQ QPU job results (JSON format)", 
+                     classes="text-caption text-medium-emphasis mb-2")
+            
+            # Platform selector
+            with vuetify3.VRow(dense=True, classes="mb-2"):
+                with vuetify3.VCol(cols=6):
+                    with vuetify3.VTooltip(location="top"):
+                        with vuetify3.Template(v_slot_activator="{ props }"):
+                            vuetify3.VSelect(
+                                v_bind="props",
+                                label="Platform",
+                                v_model=("qlbm_job_platform", "IBM"),
+                                items=("['IBM', 'IonQ']",),
+                                density="compact",
+                                hide_details=True,
+                                color="primary",
+                            )
+                        html.Span("Select the quantum hardware provider")
+                with vuetify3.VCol(cols=6):
+                    with vuetify3.VTooltip(location="top"):
+                        with vuetify3.Template(v_slot_activator="{ props }"):
+                            vuetify3.VTextField(
+                                v_bind="props",
+                                label="Output Resolution",
+                                v_model=("qlbm_job_output_resolution", 40),
+                                type="number",
+                                density="compact",
+                                hide_details=True,
+                                color="primary",
+                            )
+                        html.Span("Resolution for 3D visualization. Should be <= Grid Size (2^n).")
+            
+            # Timesteps input
+            with vuetify3.VTooltip(location="top"):
+                with vuetify3.Template(v_slot_activator="{ props }"):
+                    vuetify3.VTextField(
+                        v_bind="props",
+                        label="Total Time",
+                        v_model=("qlbm_job_total_time", 3),
+                        type="number",
+                        density="compact",
+                        hide_details=True,
+                        color="primary",
+                        classes="mb-2",
+                        hint="Enter the total time T used when running the job",
+                    )
+                html.Span("Total number of time steps in the uploaded job")
+            
+            # Advanced options (flag qubits, mid-circuit measurement) - HIDDEN
+            # Defaulting to True for both as per user request
+            
+            # File upload and Generate button
+            with vuetify3.VRow(dense=True, classes="align-center mt-2"):
+                with vuetify3.VCol(cols=8):
+                    vuetify3.VFileInput(
+                        label="Upload Job Result (JSON)",
+                        v_model=("qlbm_job_upload", None),
+                        accept=".json",
+                        prepend_icon="mdi-file-upload",
+                        density="compact",
+                        hide_details=True,
+                        color="primary",
+                        show_size=True,
+                        clearable=True,
+                    )
+                with vuetify3.VCol(cols=4):
+                    vuetify3.VBtn(
+                        text="Generate",
+                        color="secondary",
+                        variant="tonal",
+                        block=True,
+                        disabled=("!qlbm_job_upload || qlbm_job_is_processing", True),
+                        loading=("qlbm_job_is_processing", False),
+                        click=process_uploaded_job_result,
+                        prepend_icon="mdi-chart-box-outline",
+                    )
+            
+            # Success message
+            vuetify3.VAlert(
+                v_if="qlbm_job_upload_success",
+                type="success",
+                variant="tonal",
+                density="compact",
+                closable=True,
+                children=["{{ qlbm_job_upload_success }}"],
+                classes="mt-2",
+            )
+            
+            # Error message
+            vuetify3.VAlert(
+                v_if="qlbm_job_upload_error",
+                type="error",
+                variant="tonal",
+                density="compact",
+                closable=True,
+                children=["{{ qlbm_job_upload_error }}"],
+                classes="mt-2",
+            )
 
 
 def _build_visualization_panel(plotter):