diff --git a/src/blocks/HistoryLineTooltip.svelte b/src/blocks/HistoryLineTooltip.svelte
index 87fb4b40..5d53e3ea 100644
--- a/src/blocks/HistoryLineTooltip.svelte
+++ b/src/blocks/HistoryLineTooltip.svelte
@@ -18,6 +18,8 @@
    */
   export let sensor;
 
+  export let prop = 'displayName';
+
   $: items = item && view ? view.data('values').filter((d) => d.time_value === item.time_value) : [];
 </script>
 
@@ -26,7 +28,7 @@
   <table>
     {#each items as i}
       <tr>
-        <th>{i.displayName}</th>
+        <th>{i[prop]}</th>
         <td>
           <SensorValue {sensor} value={i.value} medium />
         </td>
diff --git a/src/blocks/SensorsLineTooltip.svelte b/src/blocks/SensorsLineTooltip.svelte
new file mode 100644
index 00000000..acbfb07b
--- /dev/null
+++ b/src/blocks/SensorsLineTooltip.svelte
@@ -0,0 +1,58 @@
+<script>
+  import { formatDateShortDayOfWeekAbbr } from '../formats';
+  import SensorValue from '../components/SensorValue.svelte';
+
+  export let hidden = false;
+  /**
+   * @type {import('../../data').EpiDataRow}
+   */
+  export let item;
+
+  /**
+   * @type {View}
+   */
+  export let view;
+
+  /**
+   * @type {import('../../stores/params').Sensor[]}
+   */
+  export let sensors;
+
+  export let prop = 'sensorName';
+
+  $: items = item && view ? view.data('values').filter((d) => d.time_value === item.time_value) : [];
+</script>
+
+<div aria-label="tooltip" class="tooltip" class:hidden>
+  <h5>{formatDateShortDayOfWeekAbbr(item.date_value)}</h5>
+  <table>
+    {#each items as i, index}
+      <tr>
+        <th>{i[prop]}</th>
+        <td>
+          <SensorValue sensor={sensors[index]} value={i.value} medium />
+        </td>
+      </tr>
+    {/each}
+  </table>
+</div>
+
+<style>
+  .hidden {
+    display: none;
+  }
+
+  h5 {
+    margin: 0;
+    padding: 0;
+  }
+
+  th {
+    text-align: left;
+    max-width: 15em;
+  }
+  td {
+    text-align: right;
+    vertical-align: top;
+  }
+</style>
diff --git a/src/components/RegionSearch.svelte b/src/components/RegionSearch.svelte
index 7adf6629..efb88503 100644
--- a/src/components/RegionSearch.svelte
+++ b/src/components/RegionSearch.svelte
@@ -27,11 +27,13 @@
   selectOnClick
   {selectedItem}
   {selectedItems}
+  clear={selectedItems == null}
   labelFieldName="displayName"
   keywordFunction={combineKeywords}
   maxItemsToShowInList={15}
   on:change
   on:add
+  on:remove
 >
   <svelte:fragment slot="entry" let:label let:item let:onClick>
     <a class="search-box-link" href="?region={item ? item.id : ''}" on:click|preventDefault={onClick}>
diff --git a/src/components/Search.svelte b/src/components/Search.svelte
index 416fb65f..db3a5e16 100644
--- a/src/components/Search.svelte
+++ b/src/components/Search.svelte
@@ -334,6 +334,7 @@
     />
     {#if clear}
       <button
+        type="button"
         class="uk-search-icon clear-button"
         class:hidden={!text}
         class:modern
@@ -349,6 +350,7 @@
       <div class="search-tag">
         <span>{labelFunction(selectedItem)}</span>
         <button
+          type="button"
           class=""
           data-uk-icon="icon: close"
           on:click={() => removeItem(selectedItem)}
@@ -376,14 +378,18 @@
         on:keypress={onKeyPress}
       />
     {/if}
-    <button
-      class="uk-search-icon clear-button"
-      class:modern
-      class:hidden={selectedItems.length === 0}
-      on:click={onResetItem}
-      title="Clear Search Field"
-      data-uk-icon="icon: close"
-    />
+
+    {#if clear}
+      <button
+        type="button"
+        class="uk-search-icon clear-button"
+        class:modern
+        class:hidden={selectedItems.length === 0}
+        on:click={onResetItem}
+        title="Clear Search Field"
+        data-uk-icon="icon: close"
+      />
+    {/if}
   {/if}
 
   <div class="uk-dropdown uk-dropdown-bottom-left search-box-list" class:uk-open={opened} bind:this={listRef}>
diff --git a/src/components/SensorSearch.svelte b/src/components/SensorSearch.svelte
index d6292ec1..b751100c 100644
--- a/src/components/SensorSearch.svelte
+++ b/src/components/SensorSearch.svelte
@@ -26,12 +26,14 @@
   icon="database"
   {selectedItem}
   {selectedItems}
+  clear={selectedItems == null}
   selectOnClick
   labelFieldName="name"
   keywordFunction={combineKeywords}
   maxItemsToShowInList={11}
   on:change
   on:add
+  on:remove
 >
   <svelte:fragment slot="entry" let:label let:item let:onClick>
     <a
diff --git a/src/data/sensor.ts b/src/data/sensor.ts
index dd36496a..4ef53874 100644
--- a/src/data/sensor.ts
+++ b/src/data/sensor.ts
@@ -205,3 +205,40 @@ export function resolveDefaultRegion(sensor: Sensor): Region {
   }
   return nationInfo;
 }
+
+/**
+ * checks whether multiple regions of the same sensor can be shown on a single axis without harm
+ * @param sensor
+ * @returns
+ */
+export function isComparableAcrossRegions(sensor: Sensor): boolean {
+  return sensor.format === 'fraction' || sensor.format === 'per100k' || sensor.format === 'percent';
+}
+
+/**
+ * groups sensor by their compatibility, i.e. can be shown on the same axis
+ */
+export function toSignalCompatibilityGroups(sensors: readonly Sensor[]): Sensor[][] {
+  if (sensors.length === 1) {
+    return [sensors.slice()];
+  }
+  const byFormat = new Map<string, Sensor[]>();
+  const byFormatList: Sensor[][] = [];
+  for (const sensor of sensors) {
+    if (isComparableAcrossRegions(sensor)) {
+      // can combine with others of same format
+      const entry = byFormat.get(sensor.format);
+      if (entry) {
+        entry.push(sensor);
+      } else {
+        const list = [sensor];
+        byFormatList.push(list);
+        byFormat.set(sensor.format, list);
+      }
+    } else {
+      // need to be alone
+      byFormatList.push([sensor]);
+    }
+  }
+  return byFormatList;
+}
diff --git a/src/modes/dashboard/WidgetConfigurator.svelte b/src/modes/dashboard/WidgetConfigurator.svelte
index c0c628b0..1ea0db8c 100644
--- a/src/modes/dashboard/WidgetConfigurator.svelte
+++ b/src/modes/dashboard/WidgetConfigurator.svelte
@@ -4,6 +4,7 @@
   import RegionPicker from './config/RegionPicker.svelte';
   import SensorPicker from './config/SensorPicker.svelte';
   import SensorsPicker from './config/SensorsPicker.svelte';
+  import RegionsPicker from './config/RegionsPicker.svelte';
   import TimeFramePicker from './config/TimeFramePicker.svelte';
   import { findWidget } from './state';
 
@@ -35,6 +36,9 @@
 {#if hasConfig.has('region')}
   <RegionPicker {region} value={config.region || ''} />
 {/if}
+{#if hasConfig.has('regions')}
+  <RegionsPicker {region} value={config.regions || ''} />
+{/if}
 {#if hasConfig.has('level')}
   <LevelPicker {region} value={config.level} />
 {/if}
diff --git a/src/modes/dashboard/WidgetFactory.svelte b/src/modes/dashboard/WidgetFactory.svelte
index 784ed111..e620b6b7 100644
--- a/src/modes/dashboard/WidgetFactory.svelte
+++ b/src/modes/dashboard/WidgetFactory.svelte
@@ -10,12 +10,16 @@
   import SensorTableWidget from './widgets/SensorTableWidget.svelte';
   import AnomaliesWidget from './widgets/AnomaliesWidget.svelte';
   import ZoomedMapChartWidget from './widgets/ZoomedMapChartWidget.svelte';
+  import SensorLineChartWidget from './widgets/SensorLineChartWidget.svelte';
+  import RegionLineChartWidget from './widgets/RegionLineChartWidget.svelte';
   import {
     resolveDate,
     resolveRegion,
     resolveRegionLevel,
+    resolveRegions,
     resolveSensor,
     resolveSensors,
+    resolveSensorParams,
     resolveTimeFrame,
   } from './configResolver';
 
@@ -54,6 +58,28 @@
     id={c.id}
     initialState={c.state}
   />
+{:else if c.type === 'sensorsline'}
+  <SensorLineChartWidget
+    sensors={resolveSensorParams(sensor, c.config.sensors)}
+    timeFrame={resolveTimeFrame(sensor, date, c.config.timeFrame)}
+    region={resolveRegion(region, c.config.region)}
+    bind:highlight
+    on:action={trackAction}
+    on:state={trackState}
+    id={c.id}
+    initialState={c.state}
+  />
+{:else if c.type === 'regionsline'}
+  <RegionLineChartWidget
+    sensor={resolveSensor(sensor, c.config.sensor)}
+    timeFrame={resolveTimeFrame(sensor, date, c.config.timeFrame)}
+    regions={resolveRegions(region, c.config.regions)}
+    bind:highlight
+    on:action={trackAction}
+    on:state={trackState}
+    id={c.id}
+    initialState={c.state}
+  />
 {:else if c.type === 'map'}
   <MapChartWidget
     sensor={resolveSensor(sensor, c.config.sensor)}
diff --git a/src/modes/dashboard/config/RegionsPicker.svelte b/src/modes/dashboard/config/RegionsPicker.svelte
new file mode 100644
index 00000000..bfb39078
--- /dev/null
+++ b/src/modes/dashboard/config/RegionsPicker.svelte
@@ -0,0 +1,65 @@
+<script>
+  import RegionSearch from '../../../components/RegionSearch.svelte';
+  import { getInfoByName } from '../../../data/regions';
+  import { sortedNameInfos } from '../utils';
+
+  /**
+   * @type {import("../../../stores/params").RegionParam}
+   */
+  export let region;
+
+  /**
+   * @type {string[]}
+   */
+  export let value = [];
+
+  let syncedValues = value ? (Array.isArray(value) ? value : [value]) : [''];
+
+  $: defaultRegion = {
+    id: '',
+    displayName: `Use Configured: ${region.displayName}`,
+  };
+  $: allItems = [defaultRegion, ...sortedNameInfos];
+
+  function toKey(e) {
+    return !e.detail || e.detail.id === '' ? '' : `${e.detail.id}@${e.detail.level}`;
+  }
+
+  $: selectedItems = syncedValues.map((d) => (!d ? defaultRegion : getInfoByName(d)));
+</script>
+
+<div class="regions-picker">
+  <label for="widget-adder-r" class="uk-form-label">Geographic Regions</label>
+  {#each syncedValues as s}
+    <input type="hidden" value={s} name="regions" />
+  {/each}
+  <RegionSearch
+    items={allItems}
+    {selectedItems}
+    on:change={(e) => {
+      syncedValues = e.detail ? [toKey(e)] : [''];
+    }}
+    on:add={(e) => {
+      if (syncedValues.length === 1 && syncedValues[0] === '') {
+        // replace default
+        syncedValues = [toKey(e)];
+      } else {
+        syncedValues = [...syncedValues, toKey(e)];
+      }
+    }}
+    on:remove={(e) => {
+      if (syncedValues.length === 1) {
+        syncedValues = [''];
+      } else {
+        const key = toKey(e);
+        syncedValues = syncedValues.filter((d) => d !== key);
+      }
+    }}
+  />
+</div>
+
+<style>
+  .regions-picker :global(.search-multiple) {
+    max-width: 35em;
+  }
+</style>
diff --git a/src/modes/dashboard/config/SensorsPicker.svelte b/src/modes/dashboard/config/SensorsPicker.svelte
index 63c28f80..12e1cd03 100644
--- a/src/modes/dashboard/config/SensorsPicker.svelte
+++ b/src/modes/dashboard/config/SensorsPicker.svelte
@@ -44,11 +44,18 @@
         syncedValues = [...syncedValues, e.detail.key];
       }
     }}
+    on:remove={(e) => {
+      if (syncedValues.length === 1) {
+        syncedValues = [''];
+      } else {
+        syncedValues = syncedValues.filter((d) => d !== e.detail.key);
+      }
+    }}
   />
 </div>
 
 <style>
-  .sensors-picker :global(.serach-multiple) {
+  .sensors-picker :global(.search-multiple) {
     max-width: 35em;
   }
 </style>
diff --git a/src/modes/dashboard/configResolver.ts b/src/modes/dashboard/configResolver.ts
index f2f94bb9..9cd4088b 100644
--- a/src/modes/dashboard/configResolver.ts
+++ b/src/modes/dashboard/configResolver.ts
@@ -1,6 +1,13 @@
 import { parseAPITime } from '../../data';
-import { getInfoByName } from '../../data/regions';
-import { DateParam, RegionLevel, RegionParam, Sensor, SensorParam, TimeFrame } from '../../stores/params';
+import {
+  getInfoByName,
+  nationInfo,
+  getHHSRegionOfState,
+  getStateOfCounty,
+  StateInfo,
+  CountyInfo,
+} from '../../data/regions';
+import { DateParam, Region, RegionLevel, RegionParam, Sensor, SensorParam, TimeFrame } from '../../stores/params';
 
 export function resolveSensor(defaultSensor: SensorParam, key?: string): SensorParam {
   if (!key) {
@@ -29,6 +36,25 @@ export function resolveSensors(defaultSensor: SensorParam, keys?: readonly strin
   return keys.map((k) => defaultSensor.manager.getSensor(k)).filter((d): d is Sensor => d != null);
 }
 
+export function resolveSensorParams(defaultSensor: SensorParam, keys?: readonly string[]): SensorParam[] {
+  const CASES = new SensorParam(defaultSensor.manager.getDefaultCasesSignal()!, defaultSensor.manager);
+  const DEATHS = new SensorParam(defaultSensor.manager.getDefaultDeathSignal()!, defaultSensor.manager);
+
+  if (!keys || keys.length === 0 || (keys.length === 1 && !keys[0])) {
+    if (defaultSensor.key === CASES.key || defaultSensor.key === DEATHS.key) {
+      return [CASES, DEATHS];
+    }
+    return [defaultSensor, CASES, DEATHS];
+  }
+  if (typeof keys === 'string') {
+    return [resolveSensor(defaultSensor, keys)];
+  }
+  return keys
+    .map((k) => (k ? defaultSensor.manager.getSensor(k) : defaultSensor))
+    .filter((d): d is Sensor => d != null)
+    .map((s) => new SensorParam(s, defaultSensor.manager));
+}
+
 export function resolveRegion(defaultRegion: RegionParam, r?: string): RegionParam {
   if (!r) {
     return defaultRegion;
@@ -40,6 +66,39 @@ export function resolveRegion(defaultRegion: RegionParam, r?: string): RegionPar
   return new RegionParam(rr);
 }
 
+export function resolveRegions(defaultRegion: RegionParam, keys?: string[] | string): RegionParam[] {
+  const regions: RegionParam[] = [];
+  if (!keys || keys.length === 0 || (keys.length === 1 && !keys[0])) {
+    // derive default
+    regions.push(defaultRegion);
+    if (defaultRegion.level === 'nation') {
+      return regions;
+    }
+    if (defaultRegion.level === 'state') {
+      const hhs = getHHSRegionOfState(defaultRegion.value as StateInfo);
+      if (hhs) {
+        regions.push(new RegionParam(hhs));
+      }
+    }
+    if (defaultRegion.level === 'county') {
+      const state = getStateOfCounty(defaultRegion.value as CountyInfo);
+      if (state) {
+        regions.push(new RegionParam(state));
+      }
+    }
+    regions.push(new RegionParam(nationInfo));
+    return regions;
+  }
+  if (typeof keys === 'string') {
+    const rr = keys ? getInfoByName(keys) : defaultRegion;
+    return rr ? [new RegionParam(rr)] : [defaultRegion];
+  }
+  return (keys as string[])
+    .map((ri) => (ri ? getInfoByName(ri) : defaultRegion))
+    .filter((r): r is Region => r != null)
+    .map((r) => new RegionParam(r));
+}
+
 export function resolveRegionLevel(defaultRegion: RegionParam, level?: RegionLevel): RegionLevel {
   if (!level) {
     return defaultRegion.level;
diff --git a/src/modes/dashboard/state.ts b/src/modes/dashboard/state.ts
index 992594d4..f7ae28c3 100644
--- a/src/modes/dashboard/state.ts
+++ b/src/modes/dashboard/state.ts
@@ -13,11 +13,13 @@ export type WidgetType =
   | 'regionpcp'
   | 'datepcp'
   | 'anomalies'
-  | 'zoomedmap';
+  | 'zoomedmap'
+  | 'sensorsline'
+  | 'regionsline';
 
 export type WidgetFocus = 'time' | 'region' | 'indicator';
 export type WidgetCategory = 'chart' | 'table' | 'simple' | 'advanced';
-export type WidgetConfigOption = 'sensor' | 'region' | 'timeFrame' | 'date' | 'level' | 'sensors';
+export type WidgetConfigOption = 'sensor' | 'region' | 'timeFrame' | 'date' | 'level' | 'sensors' | 'regions';
 
 export interface Widget {
   id: WidgetType;
@@ -88,6 +90,8 @@ function asWidget(
 
 export const widgets: readonly Widget[] = [
   asWidget('line', 'Time Series', ['time'], 'chart', ['sensor', 'region', 'timeFrame']),
+  asWidget('sensorsline', 'Multi Indicator Time Series', ['time'], 'chart', ['sensors', 'region', 'timeFrame']),
+  asWidget('regionsline', 'Multi Region Time Series', ['time'], 'chart', ['sensor', 'regions', 'timeFrame']),
   asWidget('map', 'Choropleth Map', ['region'], 'chart', ['sensor', 'level', 'date']),
   asWidget('zoomedmap', 'Zoomed Choropleth Map', ['region'], 'chart', ['sensor', 'region', 'date']),
   asWidget('hex', 'Hexagon Map', ['region'], 'chart', ['sensor', 'date']),
diff --git a/src/modes/dashboard/widgets/RegionLineChartWidget.svelte b/src/modes/dashboard/widgets/RegionLineChartWidget.svelte
new file mode 100644
index 00000000..ad600503
--- /dev/null
+++ b/src/modes/dashboard/widgets/RegionLineChartWidget.svelte
@@ -0,0 +1,188 @@
+<script context="module">
+  const DEFAULT_STATE = {
+    ...DEFAULT_WIDGET_STATE,
+    width: 3,
+    height: 2,
+    zero: true,
+  };
+</script>
+
+<script>
+  import Vega from '../../../components/vega/Vega.svelte';
+  import WidgetCard, { DEFAULT_WIDGET_STATE } from './WidgetCard.svelte';
+  import { getContext } from 'svelte';
+  import DownloadMenu from '../../../components/DownloadMenu.svelte';
+  import {
+    generateCompareLineSpec,
+    resolveHighlightedDate,
+    patchHighlightTuple,
+    generateDualAxisSpec,
+  } from '../../../specs/lineSpec';
+  import { formatDateISO, formatWeek } from '../../../formats';
+  import { WidgetHighlight } from '../highlight';
+  import { createEventDispatcher } from 'svelte';
+  import { EpiWeek } from '../../../data/EpiWeek';
+  import { isComparableAcrossRegions } from '../../../data/sensor';
+  import HistoryLineTooltip from '../../../blocks/HistoryLineTooltip.svelte';
+  import Toggle from '../../../components/Toggle.svelte';
+  import { highlightToDate, joinLabels, updateVegaHighlight } from './utils';
+
+  const dispatch = createEventDispatcher();
+
+  export let id = undefined;
+  /**
+   * @type {import("../../../stores/params").SensorParam}
+   */
+  export let sensor;
+  /**
+   * @type {import("../../../stores/params").TimeFrame}
+   */
+  export let timeFrame;
+  /**
+   * @type {import("../../../stores/params").RegionParam[]}
+   */
+  export let regions;
+
+  /**
+   * two way binding
+   * @type {import('../highlight').WidgetHighlight | null}
+   */
+  export let highlight = null;
+
+  export let initialState = DEFAULT_STATE;
+  let zoom = !initialState.zero;
+
+  $: canCompare = isComparableAcrossRegions(sensor.value);
+  $: visibleRegions = canCompare ? regions : regions.slice(0, Math.min(2, regions.length));
+
+  let superState = {};
+  $: state = {
+    ...initialState,
+    ...superState,
+    zero: !zoom,
+  };
+  $: {
+    dispatch('state', { id, state });
+  }
+  function mergeState(event) {
+    superState = event.detail.state;
+  }
+
+  /**
+   * @type {import("../../../stores/DataFetcher").DataFetcher}
+   */
+  const fetcher = getContext('fetcher');
+
+  /**
+   * @param {import('../../../stores/params').SensorParam} sensor
+   * @param {import('../../../stores/params').RegionParam[]} regions
+   * @param {import('../../../stores/params').TimeFrame} timeFrame
+   * @param {{zero: boolean, canCompare: boolean}} options
+   */
+  function genSpec(sensor, regions, timeFrame, { canCompare, zero }) {
+    const isWeekly = sensor.value.isWeeklySignal;
+    /**
+     * @type {import('../../../specs/lineSpec').LineSpecOptions}
+     */
+    const options = {
+      initialDate: highlightToDate(highlight) || timeFrame.max,
+      domain: timeFrame.domain,
+      zero,
+      valueFormat: sensor.value.formatSpecifier,
+      xTitle: sensor.xAxis,
+      title: [`${sensor.name}`, timeFrame.toNiceString(isWeekly)],
+      subTitle: sensor.unit,
+      highlightRegion: false,
+      clearHighlight: false,
+      autoAlignOffset: 60,
+      paddingTop: 80,
+      isWeeklySignal: isWeekly,
+      compareField: 'displayName',
+      legend: true,
+      tooltip: true,
+    };
+    const names = regions.map((region) => region.displayName);
+    if (canCompare) {
+      return generateCompareLineSpec(names, options);
+    }
+    return generateDualAxisSpec(names.slice(0, 1), names.slice(1), options);
+  }
+
+  /**
+   * @param {import("../../../stores/params").SensorParam} sensor
+   * @param {import("../../../stores/params").RegionParam[]} regions
+   * @param {import("../../../stores/params").TimeFrame} timeFrame
+   * @param {boolean} raw
+   */
+  function loadData(sensor, regions, timeFrame) {
+    return fetcher.fetch1SensorNRegionsNDates(sensor, regions, timeFrame);
+  }
+
+  /**
+   * @param {import("../../../stores/params").SensorParam} sensor
+   * @param {import("../../../stores/params").Region region
+   */
+  function generateFileName(sensor, regions, timeFrame) {
+    const regionName = regions.map((region) => `${region.propertyId}-${region.displayName}`);
+    let suffix = '';
+    return `${sensor.name}_${regionName}_${
+      sensor.isWeeklySignal ? formatWeek(timeFrame.min_week) : formatDateISO(timeFrame.min)
+    }-${sensor.isWeeklySignal ? formatWeek(timeFrame.max_week) : formatDateISO(timeFrame.max)}${suffix}`;
+  }
+
+  $: spec = genSpec(sensor, visibleRegions, timeFrame, { canCompare, zero: !zoom });
+  $: data = loadData(sensor, visibleRegions, timeFrame);
+  $: fileName = generateFileName(sensor, visibleRegions, timeFrame);
+
+  let vegaRef = null;
+
+  function onHighlightSignal(event) {
+    const date = resolveHighlightedDate(event);
+    const newHighlight = new WidgetHighlight(
+      sensor.value,
+      visibleRegions.map((r) => r.value),
+      sensor.isWeeklySignal ? EpiWeek.fromDate(date) : date,
+    );
+    if (!newHighlight.equals(highlight)) {
+      highlight = newHighlight;
+    }
+  }
+
+  $: highlighted = highlight != null && highlight.matches(sensor.value, visibleRegions[0], timeFrame);
+
+  function updateVegaHighlightImpl(highlight) {
+    updateVegaHighlight(vegaRef, highlight);
+  }
+  $: {
+    updateVegaHighlightImpl(highlight);
+  }
+</script>
+
+<WidgetCard
+  {initialState}
+  defaultState={DEFAULT_STATE}
+  {highlighted}
+  region={visibleRegions.length === 1 ? visibleRegions[0] : joinLabels(visibleRegions.map((d) => d.displayName))}
+  {sensor}
+  date={timeFrame}
+  {id}
+  on:action
+  on:state={mergeState}
+  resizeMode="x"
+>
+  <Vega
+    bind:this={vegaRef}
+    {spec}
+    {data}
+    style="margin-top: -58px;"
+    signals={{ highlight_tuple: patchHighlightTuple }}
+    signalListeners={['highlight']}
+    on:signal_highlight={onHighlightSignal}
+    tooltip={HistoryLineTooltip}
+    tooltipProps={{ sensor }}
+  />
+  <svelte:fragment slot="toolbar">
+    <Toggle bind:checked={zoom} noPadding>Rescale Y-axis</Toggle>
+    <DownloadMenu {fileName} {vegaRef} {data} {sensor} advanced={false} />
+  </svelte:fragment>
+</WidgetCard>
diff --git a/src/modes/dashboard/widgets/SensorLineChartWidget.svelte b/src/modes/dashboard/widgets/SensorLineChartWidget.svelte
new file mode 100644
index 00000000..a00b6362
--- /dev/null
+++ b/src/modes/dashboard/widgets/SensorLineChartWidget.svelte
@@ -0,0 +1,210 @@
+<script context="module">
+  const DEFAULT_STATE = {
+    ...DEFAULT_WIDGET_STATE,
+    width: 3,
+    height: 2,
+    zero: true,
+  };
+</script>
+
+<script>
+  import Vega from '../../../components/vega/Vega.svelte';
+  import WidgetCard, { DEFAULT_WIDGET_STATE } from './WidgetCard.svelte';
+  import { getContext } from 'svelte';
+  import DownloadMenu from '../../../components/DownloadMenu.svelte';
+  import {
+    generateCompareLineSpec,
+    resolveHighlightedDate,
+    patchHighlightTuple,
+    generateDualAxisSpec,
+  } from '../../../specs/lineSpec';
+  import { formatDateISO } from '../../../formats';
+  import { WidgetHighlight } from '../highlight';
+  import { createEventDispatcher } from 'svelte';
+  import { EpiWeek } from '../../../data/EpiWeek';
+  import { toSignalCompatibilityGroups } from '../../../data/sensor';
+  import SensorsLineTooltip from '../../../blocks/SensorsLineTooltip.svelte';
+  import Toggle from '../../../components/Toggle.svelte';
+  import { highlightToDate, joinLabels, updateVegaHighlight } from './utils';
+
+  const dispatch = createEventDispatcher();
+
+  export let id = undefined;
+  /**
+   * @type {import("../../../stores/params").SensorParam[]}
+   */
+  export let sensors;
+  /**
+   * @type {import("../../../stores/params").TimeFrame}
+   */
+  export let timeFrame;
+  /**
+   * @type {import("../../../stores/params").RegionParam}
+   */
+  export let region;
+
+  /**
+   * two way binding
+   * @type {import('../highlight').WidgetHighlight | null}
+   */
+  export let highlight = null;
+
+  export let initialState = DEFAULT_STATE;
+  let zoom = !initialState.zero;
+
+  $: sensorGroups = toSignalCompatibilityGroups(sensors.map((s) => s.value));
+  $: visibleSensors = sensorGroups.length > 2 ? sensorGroups.slice(0, 2) : sensorGroups;
+  $: flatSensors = visibleSensors.flat();
+  $: refSensor = flatSensors[0];
+
+  let superState = {};
+  $: state = {
+    ...initialState,
+    ...superState,
+    zero: !zoom,
+  };
+  $: {
+    dispatch('state', { id, state });
+  }
+  function mergeState(event) {
+    superState = event.detail.state;
+  }
+
+  /**
+   * @type {import("../../../stores/DataFetcher").DataFetcher}
+   */
+  const fetcher = getContext('fetcher');
+
+  /**
+   * @param {import('../../../stores/params').Sensor[][]} sensors
+   * @param {import('../../../stores/params').RegionParam} region
+   * @param {import('../../../stores/params').TimeFrame} timeFrame
+   * @param {{zero: boolean}} options
+   */
+  function genSpec(sensors, region, timeFrame, { zero }) {
+    const flatSensors = sensors.flat();
+    const isWeekly = sensors[0][0].isWeeklySignal;
+    /**
+     * @type {import('../../../specs/lineSpec').LineSpecOptions}
+     */
+    const options = {
+      initialDate: highlightToDate(highlight) || timeFrame.max,
+      domain: timeFrame.domain,
+      zero,
+      valueFormat: flatSensors[0].formatSpecifier,
+      valueFormatRight: sensors.length > 1 ? sensors[1][0].formatSpecifier : undefined,
+      xTitle: flatSensors[0].xAxis,
+      title: [`${flatSensors[0].name} in ${region.displayName}`, timeFrame.toNiceString(isWeekly)],
+      subTitle: sensors.map((s) => s[0].unit).join(', '),
+      highlightRegion: false,
+      clearHighlight: false,
+      autoAlignOffset: 60,
+      paddingTop: 80,
+      isWeeklySignal: isWeekly,
+      compareField: 'sensorName',
+      legend: true,
+      tooltip: true,
+    };
+    if (sensorGroups.length === 1) {
+      return generateCompareLineSpec(
+        sensors[0].map((d) => d.name),
+        options,
+      );
+    }
+    return generateDualAxisSpec(
+      sensors[0].map((d) => d.name),
+      sensors[1].map((d) => d.name),
+      options,
+    );
+  }
+
+  /**
+   * @param {import("../../../stores/params").SensorParam[]} sensors
+   * @param {import("../../../stores/params").RegionParam} regions
+   * @param {import("../../../stores/params").TimeFrame} timeFrame
+   * @param {boolean} raw
+   */
+  function loadData(flatSensors, region, timeFrame) {
+    return Promise.all(fetcher.fetchNSensor1RegionNDates(flatSensors, region, timeFrame)).then((rows) => {
+      rows.forEach((sensorRows, i) => {
+        const sensor = flatSensors[i];
+        sensorRows.forEach((row) => {
+          row.sensorName = sensor.name;
+        });
+      });
+      return rows.flat();
+    });
+  }
+
+  /**
+   * @param {import("../../../stores/params").SensorParam} sensor
+   * @param {import("../../../stores/params").Region region
+   */
+  function generateFileName(sensors, region, timeFrame) {
+    const names = sensors.map((sensor) => `${sensor.name}`);
+
+    return `${names}_${region.displayName}_${formatDateISO(timeFrame.min)}-${formatDateISO(timeFrame.max)}`;
+  }
+
+  $: spec = genSpec(visibleSensors, region, timeFrame, { zero: !zoom });
+  $: data = loadData(flatSensors, region, timeFrame);
+  $: fileName = generateFileName(flatSensors, region, timeFrame);
+
+  let vegaRef = null;
+
+  function onHighlightSignal(event) {
+    const date = resolveHighlightedDate(event);
+    const newHighlight = new WidgetHighlight(
+      refSensor,
+      visibleSensors.map((r) => r.value),
+      refSensor.isWeeklySignal ? EpiWeek.fromDate(date) : date,
+    );
+    if (!newHighlight.equals(highlight)) {
+      highlight = newHighlight;
+    }
+  }
+
+  $: highlighted = highlight != null && highlight.matches(refSensor, region, timeFrame);
+
+  function updateVegaHighlightImpl(highlight) {
+    updateVegaHighlight(vegaRef, highlight);
+  }
+  $: {
+    updateVegaHighlightImpl(highlight);
+  }
+</script>
+
+<WidgetCard
+  {initialState}
+  defaultState={DEFAULT_STATE}
+  {highlighted}
+  {region}
+  sensor={flatSensors.length === 1
+    ? flatSensors[0]
+    : joinLabels(
+        flatSensors.map((d) => d.name),
+        'Indicators',
+      )}
+  titleUnit={visibleSensors.map((d) => d[0].unit).join(', ')}
+  date={timeFrame}
+  {id}
+  on:action
+  on:state={mergeState}
+  resizeMode="x"
+>
+  <Vega
+    bind:this={vegaRef}
+    {spec}
+    {data}
+    style="margin-top: -58px;"
+    signals={{ highlight_tuple: patchHighlightTuple }}
+    signalListeners={['highlight']}
+    on:signal_highlight={onHighlightSignal}
+    tooltip={SensorsLineTooltip}
+    tooltipProps={{ sensors: flatSensors }}
+  />
+  <svelte:fragment slot="toolbar">
+    <Toggle bind:checked={zoom} noPadding>Rescale Y-axis</Toggle>
+    <DownloadMenu {fileName} {vegaRef} {data} advanced={false} />
+  </svelte:fragment>
+</WidgetCard>
diff --git a/src/modes/dashboard/widgets/utils.ts b/src/modes/dashboard/widgets/utils.ts
new file mode 100644
index 00000000..d5e401be
--- /dev/null
+++ b/src/modes/dashboard/widgets/utils.ts
@@ -0,0 +1,46 @@
+import type { View } from 'vega';
+import isEqual from 'lodash-es/isEqual';
+import type { WidgetHighlight } from '../highlight';
+
+export function joinLabels(labels: string[], defaultLabel = 'Regions') {
+  if (labels.length === 0) {
+    return defaultLabel;
+  }
+  if (labels.length === 1) {
+    return labels[0];
+  }
+  const r = labels.slice(0, labels.length - 1).join(', ');
+  return `${r} and ${labels[labels.length - 1]}`;
+}
+
+export function highlightToDate(highlight?: WidgetHighlight | null) {
+  return highlight ? highlight.primaryDate : null;
+}
+
+export function updateVegaHighlight(vegaRef: { vegaDirectAccessor: () => View }, highlight?: WidgetHighlight | null) {
+  if (!vegaRef) {
+    return;
+  }
+  const view = vegaRef.vegaDirectAccessor();
+  if (!view) {
+    return;
+  }
+  const value = highlightToDate(highlight);
+  const values = value ? [value.getTime()] : null;
+  const newValue = value
+    ? {
+        unit: 'layer_1',
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        fields: view.signal('highlight_tuple_fields'),
+        values,
+      }
+    : null;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  const currentValues = (view.signal('highlight_tuple') || { values: [] }).values as unknown[];
+  const newValues = values || [];
+  if (isEqual(currentValues, newValues)) {
+    return;
+  }
+  view.signal('highlight_tuple', newValue);
+  void view.runAsync();
+}
diff --git a/src/specs/lineSpec.ts b/src/specs/lineSpec.ts
index 81a1cdcd..4bae4d32 100644
--- a/src/specs/lineSpec.ts
+++ b/src/specs/lineSpec.ts
@@ -283,6 +283,7 @@ export interface LineSpecOptions {
   tickCount?: Axis<ExprRef | SignalRef>['tickCount'];
   isWeeklySignal?: boolean;
   stderr?: boolean;
+  tooltip?: boolean;
 }
 
 export function generateLineChartSpec({
@@ -310,6 +311,7 @@ export function generateLineChartSpec({
     interval: 'week' as const,
     step: 1,
   },
+  tooltip = false,
   isWeeklySignal = false,
   stderr = false,
 }: LineSpecOptions = {}): TopLevelSpec & LayerSpec<Field> {
@@ -418,7 +420,7 @@ export function generateLineChartSpec({
           type: 'point',
           color,
           stroke: null,
-          tooltip: false,
+          tooltip,
         },
         encoding: {
           x: {
@@ -553,7 +555,11 @@ export function generateLineChartSpec({
 
 export function generateCompareLineSpec(
   compare: string[],
-  { compareField = 'displayName', ...options }: LineSpecOptions & { compareField?: string } = {},
+  {
+    compareField = 'displayName',
+    legend = false,
+    ...options
+  }: LineSpecOptions & { compareField?: string; legend?: boolean } = {},
 ): TopLevelSpec {
   const spec = generateLineChartSpec(options);
   spec.layer[0].encoding!.color = {
@@ -563,8 +569,19 @@ export function generateCompareLineSpec(
       domain: compare,
       range: MULTI_COLORS,
     },
-    legend: null,
+    legend: legend
+      ? {
+          direction: 'horizontal',
+          orient: 'bottom',
+          title: null,
+          labelLimit: 200,
+          symbolType: 'stroke',
+        }
+      : null,
   };
+  if (legend) {
+    (spec.padding! as { bottom: number }).bottom = 66;
+  }
   spec.layer[1].encoding!.color = {
     field: compareField,
     type: 'nominal',
@@ -572,6 +589,61 @@ export function generateCompareLineSpec(
   return spec;
 }
 
+export function generateDualAxisSpec(
+  leftAxis: string[],
+  rightAxis: string[],
+  { compareField = 'displayName', ...options }: LineSpecOptions & { compareField?: string; legend?: boolean } = {},
+): TopLevelSpec {
+  const spec = generateLineChartSpec(options);
+  (spec.padding! as { bottom: number }).bottom = 66;
+  (spec.padding! as { right: number }).right = (spec.padding! as { left: number }).left + 15;
+
+  const leftLayer = spec.layer.splice(0, 2);
+  leftLayer[0].encoding!.color = {
+    field: compareField,
+    type: 'nominal',
+    scale: {
+      domain: [...leftAxis, ...rightAxis],
+    },
+    legend: {
+      direction: 'horizontal',
+      orient: 'bottom',
+      title: null,
+      labelLimit: 200,
+      symbolType: 'stroke',
+    },
+  };
+  leftLayer[1].encoding!.color = {
+    field: compareField,
+    type: 'nominal',
+    scale: {
+      domain: [...leftAxis, ...rightAxis],
+    },
+  };
+  spec.layer.unshift(
+    {
+      transform: [
+        {
+          filter: `indexof(${JSON.stringify(leftAxis)}, datum.${compareField}) >= 0`,
+        },
+      ],
+      layer: leftLayer,
+    },
+    {
+      transform: [
+        {
+          filter: `indexof(${JSON.stringify(rightAxis)}, datum.${compareField}) >= 0`,
+        },
+      ],
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      layer: [JSON.parse(JSON.stringify(leftLayer[0]))],
+    },
+  );
+  spec.resolve = { scale: { y: 'independent' } };
+
+  return spec;
+}
+
 export function generateLineAndBarSpec(options: LineSpecOptions = {}): TopLevelSpec & LayerSpec<Field> {
   const spec = generateLineChartSpec({ ...options, stderr: false });
   const point = spec.layer[1] as NormalizedUnitSpec;