diff --git a/media/options-widget.css b/media/options-widget.css
index 23ebf4e..5275d33 100644
--- a/media/options-widget.css
+++ b/media/options-widget.css
@@ -74,6 +74,11 @@
   row-gap: 12px;
 }
 
+.form-textfield {
+  position: relative;
+  padding-bottom: 16px;
+}
+
 .form-textfield > input {
   width: 150px;
 }
@@ -89,6 +94,12 @@
   align-self: start;
 }
 
+.form-options-memory-read-argument-hint {
+  position: absolute;
+  bottom: 0;
+  color: var(--vscode-descriptionForeground);
+}
+
 .advanced-options-content h2 {
   font-size: 120%;
   margin: 0.5rem 0 0 0;
diff --git a/package.json b/package.json
index 588366d..11cdfef 100644
--- a/package.json
+++ b/package.json
@@ -214,12 +214,14 @@
           "type": "string",
           "enum": [
             "Paginate",
-            "Infinite"
+            "Grow",
+            "Auto-Append"
           ],
           "default": "Paginate",
           "enumDescriptions": [
             "Maintains a consistent memory size, replacing the previous request.",
-            "Appends new memory to bounds of current request, resulting in a growing list."
+            "Appends new memory to bounds of current request, resulting in a growing list.",
+            "Automatically appends new memory to the bounds of the current request on reaching the end of the list, resulting in a growing list."
           ],
           "description": "Behavior when adding more memory beyond the current view."
         },
diff --git a/src/webview/components/memory-table.tsx b/src/webview/components/memory-table.tsx
index 76465ad..6340bc9 100644
--- a/src/webview/components/memory-table.tsx
+++ b/src/webview/components/memory-table.tsx
@@ -28,17 +28,25 @@ import { tryToNumber } from '../../common/typescript';
 import { DataColumn } from '../columns/data-column';
 
 export interface MoreMemorySelectProps {
-    count: number;
-    offset: number;
+    activeReadArguments: Required<DebugProtocol.ReadMemoryArguments>;
     options: number[];
     direction: 'above' | 'below';
-    scrollingBehavior: ScrollingBehavior;
     fetchMemory(partialOptions?: Partial<DebugProtocol.ReadMemoryArguments>): Promise<void>;
     disabled: boolean
 }
 
-export const MoreMemorySelect: React.FC<MoreMemorySelectProps> = ({ count, offset, options, fetchMemory, direction, scrollingBehavior, disabled }) => {
-    const [numBytes, setNumBytes] = React.useState<number>(options[0]);
+export interface MoreMemoryAboveSelectProps extends MoreMemorySelectProps {
+    direction: 'above';
+    shouldPrepend?: boolean;
+}
+
+export interface MoreMemoryBelowSelectProps extends MoreMemorySelectProps {
+    direction: 'below';
+    shouldAppend?: boolean;
+}
+
+export const MoreMemorySelect: React.FC<MoreMemoryAboveSelectProps | MoreMemoryBelowSelectProps> = props => {
+    const [numBytes, setNumBytes] = React.useState<number>(props.options[0]);
     const containerRef = React.createRef<HTMLDivElement>();
     const onSelectChange = (e: React.ChangeEvent<HTMLSelectElement>): void => {
         e.stopPropagation();
@@ -46,43 +54,60 @@ export const MoreMemorySelect: React.FC<MoreMemorySelectProps> = ({ count, offse
         setNumBytes(parseInt(value));
     };
 
-    const loadMoreMemory = (e: React.MouseEvent | React.KeyboardEvent): void => {
+    const updateMemory = (e: React.MouseEvent | React.KeyboardEvent): void => {
         containerRef.current?.blur();
         if (isTrigger(e)) {
-            let newOffset = offset;
-            let newCount = count;
+            const direction = props.direction;
+
             if (direction === 'above') {
-                newOffset = offset - numBytes;
-            }
-            if (scrollingBehavior === 'Infinite') {
-                newCount = count + numBytes;
+                handleAboveDirection(props);
+            } else if (direction === 'below') {
+                handleBelowDirection(props);
             } else {
-                if (direction === 'below') {
-                    newOffset = offset + numBytes;
-                }
+                throw new Error(`Unknown direction ${direction}`);
             }
-            fetchMemory({ offset: newOffset, count: newCount });
+        }
+    };
+
+    const handleAboveDirection = (aboveProps: MoreMemoryAboveSelectProps): void => {
+        const { activeReadArguments, shouldPrepend, fetchMemory } = aboveProps;
+
+        const newOffset = activeReadArguments.offset - numBytes;
+        const newCount = shouldPrepend ? activeReadArguments.count + numBytes : activeReadArguments.count;
+
+        fetchMemory({ offset: newOffset, count: newCount });
+    };
+
+    const handleBelowDirection = (belowProps: MoreMemoryBelowSelectProps): void => {
+        const { activeReadArguments, fetchMemory } = belowProps;
+
+        if (belowProps.shouldAppend) {
+            const newCount = activeReadArguments.count + numBytes;
+            fetchMemory({ count: newCount });
+        } else {
+            const newOffset = activeReadArguments.offset + numBytes;
+            fetchMemory({ offset: newOffset });
         }
     };
 
     return (
         <div
-            className={`more-memory-select ${disabled ? 'p-disabled' : ''}`}
+            className={`more-memory-select ${props.disabled ? 'p-disabled' : ''}`}
             tabIndex={0}
             role='button'
-            onClick={loadMoreMemory}
-            onKeyDown={loadMoreMemory}
+            onClick={updateMemory}
+            onKeyDown={updateMemory}
             ref={containerRef}
         >
             <div className='more-memory-select-top no-select'>
                 Load
                 <select
-                    className={`bytes-select ${disabled ? 'p-disabled' : ''}`}
+                    className={`bytes-select ${props.disabled ? 'p-disabled' : ''}`}
                     onChange={onSelectChange}
                     tabIndex={0}
-                    disabled={disabled}
+                    disabled={props.disabled}
                 >
-                    {options.map(option => (
+                    {props.options.map(option => (
                         <option
                             key={`more-memory-select-${option}`}
                             value={option}
@@ -90,17 +115,17 @@ export const MoreMemorySelect: React.FC<MoreMemorySelectProps> = ({ count, offse
                             {option}
                         </option>))}
                 </select>
-                {`more bytes ${direction}`}
+                {`more bytes ${props.direction}`}
             </div>
         </div>
     );
 };
 
 interface MemoryTableProps extends TableRenderOptions, MemoryDisplayConfiguration {
+    configuredReadArguments: Required<DebugProtocol.ReadMemoryArguments>;
+    activeReadArguments: Required<DebugProtocol.ReadMemoryArguments>;
     memory?: Memory;
     decorations: Decoration[];
-    offset: number;
-    count: number;
     effectiveAddressLength: number;
     fetchMemory(partialOptions?: Partial<DebugProtocol.ReadMemoryArguments>): Promise<void>;
     isMemoryFetching: boolean;
@@ -145,8 +170,12 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
     protected datatableRef = React.createRef<DataTable<MemoryRowData[]>>();
     protected resizeObserver?: ResizeObserver;
 
-    protected get isShowMoreEnabled(): boolean {
-        return !!this.props.memory?.bytes.length;
+    protected get datatableWrapper(): HTMLElement | undefined {
+        return this.datatableRef.current?.getElement().querySelector<HTMLElement>('[data-pc-section="wrapper"]') ?? undefined;
+    }
+
+    protected get isLoading(): boolean {
+        return this.props.isMemoryFetching;
     }
 
     constructor(props: MemoryTableProps) {
@@ -167,6 +196,11 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
         this.resizeObserver = new ResizeObserver(entries => {
             if (entries.length > 0) {
                 this.autofitColumns();
+
+                // The size changed - we could have too few rows visible to enable a scrollbar
+                if (this.props.scrollingBehavior === 'Auto-Append') {
+                    this.ensureSufficientVisibleRowsForScrollbar();
+                }
             }
         });
 
@@ -177,7 +211,11 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
     }
 
     componentDidUpdate(prevProps: Readonly<MemoryTableProps>): void {
-        const hasMemoryChanged = prevProps.memory?.address !== this.props.memory?.address || prevProps.offset !== this.props.offset || prevProps.count !== this.props.count;
+        const hasMemoryChanged = (prevProps.memory === undefined || this.props.memory === undefined)
+            || prevProps.memory.address !== this.props.memory.address
+            || prevProps.activeReadArguments.offset !== this.props.activeReadArguments.offset
+            || prevProps.activeReadArguments.count !== this.props.activeReadArguments.count;
+
         const hasOptionsChanged = prevProps.wordsPerGroup !== this.props.wordsPerGroup || prevProps.groupsPerRow !== this.props.groupsPerRow;
 
         // Reset selection
@@ -188,6 +226,22 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
         }
 
         this.ensureGroupsPerRowToRenderIsSet();
+        if (this.props.memory !== undefined && this.props.scrollingBehavior === 'Auto-Append') {
+            this.ensureSufficientVisibleRowsForScrollbar();
+
+            // We have now less count than before - there was a change from outside
+            if (prevProps.memory !== undefined && prevProps.activeReadArguments.count > this.props.activeReadArguments.count) {
+                this.datatableRef.current?.resetScroll();
+            }
+
+            // If we disable frozen, then we need to check the current position of the scrollbar and if necessary append more memory
+            if (prevProps.isFrozen && !this.props.isFrozen) {
+                const wrapper = this.datatableWrapper;
+                if (wrapper) {
+                    this.appendMoreMemoryOnListEnd(wrapper);
+                }
+            }
+        }
     }
 
     componentWillUnmount(): void {
@@ -204,7 +258,7 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
             rows = this.createTableRows(memory, options);
         }
 
-        const props = this.createDataTableProperties(rows);
+        const props = this.createScrollingBehaviorSpecificProperties(this.createDataTableProperties(rows));
         // Available width in percent without the fit columns
         const remainingWidth = 100 -
             this.props.columnOptions.filter(c => c.contribution.fittingType === 'content-width').length;
@@ -242,7 +296,6 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
         return {
             cellSelection: true,
             className: classNames(MemoryTable.TABLE_CLASS, { [MemoryTable.TABLE_GROUPS_PER_ROW_AUTOFIT]: this.props.groupsPerRow === 'Autofit' }),
-            footer: this.renderFooter(),
             header: this.renderHeader(),
             lazy: true,
             metaKeySelection: false,
@@ -258,6 +311,66 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
         };
     }
 
+    protected createScrollingBehaviorSpecificProperties(props: DataTableProps<MemoryRowData[]>): DataTableProps<MemoryRowData[]> {
+        if (this.props.scrollingBehavior === 'Auto-Append') {
+            return {
+                ...props,
+                pt: {
+                    wrapper: {
+                        onScroll: event => {
+                            this.appendMoreMemoryOnListEnd(event.currentTarget);
+                        }
+                    }
+                }
+            };
+        } else {
+            return {
+                ...props,
+                footer: this.renderFooter()
+            };
+        }
+    }
+
+    /**
+     * This method ensures that we have sufficient rows visible to enable vertical scrollbars
+     */
+    protected ensureSufficientVisibleRowsForScrollbar(): void {
+        if (this.props.memory === undefined) {
+            return;
+        }
+
+        const requestedBytesNotLoaded = this.props.activeReadArguments.count > this.props.memory.bytes.length;
+        if (requestedBytesNotLoaded) {
+            return;
+        }
+
+        const datatableValues = this.datatableRef.current?.props.value;
+        if (datatableValues && datatableValues.length < MemoryTable.renderableRowsAtOnceCountForWrapper(this.datatableWrapper)) {
+            // We have too few rows, we need to load more data
+            this.appendMoreMemory();
+        }
+    }
+
+    protected appendMoreMemory(): void {
+        if (!this.isLoading && this.props.memory !== undefined) {
+            const memorySizeOptions = MemorySizeOptions.create(this.props, this.state);
+            const options = this.createMemoryRowListOptions(this.props.memory, memorySizeOptions);
+            const newCount = this.props.activeReadArguments.count + options.wordsPerRow * MemoryTable.renderableRowsAtOnceCountForWrapper(this.datatableWrapper);
+            this.props.fetchMemory({ count: newCount });
+        }
+    }
+
+    protected appendMoreMemoryOnListEnd(element: HTMLElement): void {
+        if (!this.isLoading) {
+            // Append new data only if we reach the bottom
+            const distanceBottom = Math.abs(element.scrollHeight - element.scrollTop - element.clientHeight);
+
+            if (distanceBottom < 1) {
+                this.appendMoreMemory();
+            }
+        }
+    }
+
     protected onSelectionChanged = (event: DataTableSelectionCellChangeEvent<MemoryRowData[]>) => {
         this.setState(prev => ({ ...prev, selection: event.value }));
     };
@@ -267,26 +380,24 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
     };
 
     protected renderHeader(): React.ReactNode | undefined {
-        const { offset, count, fetchMemory, scrollingBehavior } = this.props;
-
         let memorySelect: React.ReactNode | undefined;
         let loading: React.ReactNode | undefined;
 
-        if (this.isShowMoreEnabled) {
+        if (this.props.memory !== undefined) {
+            const prependScrollingBehaviors: ScrollingBehavior[] = ['Grow', 'Auto-Append'];
             memorySelect = <div className='flex-auto'>
                 <MoreMemorySelect
-                    offset={offset}
-                    count={count}
+                    activeReadArguments={this.props.activeReadArguments}
                     options={[128, 256, 512]}
                     direction='above'
-                    scrollingBehavior={scrollingBehavior}
-                    fetchMemory={fetchMemory}
+                    shouldPrepend={prependScrollingBehaviors.includes(this.props.scrollingBehavior)}
+                    fetchMemory={this.props.fetchMemory}
                     disabled={this.props.isFrozen}
                 />
             </div>;
         }
 
-        if (this.props.isMemoryFetching) {
+        if (this.isLoading) {
             loading = <div className='absolute right-0 flex align-items-center'>
                 <ProgressSpinner style={{ width: '16px', height: '16px' }} className='mr-2' />
                 <span>Loading</span>
@@ -302,19 +413,16 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
     }
 
     protected renderFooter(): React.ReactNode | undefined {
-        const { offset, count, fetchMemory, scrollingBehavior } = this.props;
-
         let memorySelect: React.ReactNode | undefined;
 
-        if (this.isShowMoreEnabled) {
+        if (this.props.memory !== undefined) {
             memorySelect = <div className='flex-auto'>
                 <MoreMemorySelect
-                    offset={offset}
-                    count={count}
+                    activeReadArguments={this.props.activeReadArguments}
                     options={[128, 256, 512]}
                     direction='below'
-                    scrollingBehavior={scrollingBehavior}
-                    fetchMemory={fetchMemory}
+                    shouldAppend={this.props.scrollingBehavior === 'Grow'}
+                    fetchMemory={this.props.fetchMemory}
                     disabled={this.props.isFrozen}
                 />
             </div>;
@@ -393,4 +501,27 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
 export namespace MemoryTable {
     export const TABLE_CLASS = 'memory-inspector-table' as const;
     export const TABLE_GROUPS_PER_ROW_AUTOFIT = 'groups-per-row-autofit' as const;
+
+    /**
+     * Approximates how many rows visually fit into the given wrapper without scrolling
+     */
+    export function visibleRowsCountInWrapper(wrapper?: HTMLElement): number {
+        if (wrapper) {
+            const row = wrapper.querySelector<HTMLElement>('tr');
+
+            if (row) {
+                return Math.ceil(wrapper.clientHeight / row.clientHeight);
+            }
+        }
+
+        return 1;
+    }
+
+    /**
+     * Returns the number of rows that the wrapper can render at once
+     */
+    export function renderableRowsAtOnceCountForWrapper(wrapper?: HTMLElement): number {
+        const buffer = 8;
+        return visibleRowsCountInWrapper(wrapper) + buffer;
+    }
 }
diff --git a/src/webview/components/memory-widget.tsx b/src/webview/components/memory-widget.tsx
index 179ae2d..367795c 100644
--- a/src/webview/components/memory-widget.tsx
+++ b/src/webview/components/memory-widget.tsx
@@ -17,22 +17,20 @@
 import { DebugProtocol } from '@vscode/debugprotocol';
 import React from 'react';
 import { ColumnStatus } from '../columns/column-contribution-service';
-import { Decoration, Endianness, Memory, MemoryDisplayConfiguration } from '../utils/view-types';
+import { Decoration, Endianness, Memory, MemoryDisplayConfiguration, MemoryState } from '../utils/view-types';
 import { MemoryTable } from './memory-table';
 import { OptionsWidget } from './options-widget';
 
 interface MemoryWidgetProps extends MemoryDisplayConfiguration {
+    configuredReadArguments: Required<DebugProtocol.ReadMemoryArguments>;
+    activeReadArguments: Required<DebugProtocol.ReadMemoryArguments>;
     memory?: Memory;
     title: string;
     decorations: Decoration[];
     columns: ColumnStatus[];
-    memoryReference: string;
-    offset: number;
-    count: number;
     effectiveAddressLength: number;
     isMemoryFetching: boolean;
-    refreshMemory: () => void;
-    updateMemoryArguments: (memoryArguments: Partial<DebugProtocol.ReadMemoryArguments>) => void;
+    updateMemoryState: (state: Partial<MemoryState>) => void;
     toggleColumn(id: string, active: boolean): void;
     isFrozen: boolean;
     toggleFrozen: () => void;
@@ -62,25 +60,26 @@ export class MemoryWidget extends React.Component<MemoryWidgetProps, MemoryWidge
                 title={this.props.title}
                 updateTitle={this.props.updateTitle}
                 columnOptions={this.props.columns}
-                memoryReference={this.props.memoryReference}
-                offset={this.props.offset}
-                count={this.props.count}
+                configuredReadArguments={this.props.configuredReadArguments}
+                activeReadArguments={this.props.activeReadArguments}
                 endianness={this.state.endianness}
                 bytesPerWord={this.props.bytesPerWord}
                 wordsPerGroup={this.props.wordsPerGroup}
                 groupsPerRow={this.props.groupsPerRow}
-                updateMemoryArguments={this.props.updateMemoryArguments}
+                updateMemoryState={this.props.updateMemoryState}
                 updateRenderOptions={this.props.updateMemoryDisplayConfiguration}
                 resetRenderOptions={this.props.resetMemoryDisplayConfiguration}
-                refreshMemory={this.props.refreshMemory}
                 addressPadding={this.props.addressPadding}
                 addressRadix={this.props.addressRadix}
                 showRadixPrefix={this.props.showRadixPrefix}
+                fetchMemory={this.props.fetchMemory}
                 toggleColumn={this.props.toggleColumn}
                 toggleFrozen={this.props.toggleFrozen}
                 isFrozen={this.props.isFrozen}
             />
             <MemoryTable
+                configuredReadArguments={this.props.configuredReadArguments}
+                activeReadArguments={this.props.activeReadArguments}
                 decorations={this.props.decorations}
                 columnOptions={this.props.columns.filter(candidate => candidate.active)}
                 memory={this.props.memory}
@@ -88,8 +87,6 @@ export class MemoryWidget extends React.Component<MemoryWidgetProps, MemoryWidge
                 bytesPerWord={this.props.bytesPerWord}
                 wordsPerGroup={this.props.wordsPerGroup}
                 groupsPerRow={this.props.groupsPerRow}
-                offset={this.props.offset}
-                count={this.props.count}
                 effectiveAddressLength={this.props.effectiveAddressLength}
                 fetchMemory={this.props.fetchMemory}
                 isMemoryFetching={this.props.isMemoryFetching}
diff --git a/src/webview/components/options-widget.tsx b/src/webview/components/options-widget.tsx
index 1f3b776..6a7eb82 100644
--- a/src/webview/components/options-widget.tsx
+++ b/src/webview/components/options-widget.tsx
@@ -21,25 +21,24 @@ import { Dropdown, DropdownChangeEvent } from 'primereact/dropdown';
 import { InputText } from 'primereact/inputtext';
 import { OverlayPanel } from 'primereact/overlaypanel';
 import { classNames } from 'primereact/utils';
-import React, { FocusEventHandler, KeyboardEvent, KeyboardEventHandler, MouseEventHandler } from 'react';
+import React, { FocusEventHandler, KeyboardEvent, KeyboardEventHandler, MouseEventHandler, ReactNode } from 'react';
 import { TableRenderOptions } from '../columns/column-contribution-service';
-import { AddressPaddingOptions, SerializedTableRenderOptions } from '../utils/view-types';
+import { AddressPaddingOptions, MemoryState, SerializedTableRenderOptions } from '../utils/view-types';
 import { MultiSelectWithLabel } from './multi-select';
 import { CONFIG_BYTES_PER_WORD_CHOICES, CONFIG_GROUPS_PER_ROW_CHOICES, CONFIG_WORDS_PER_GROUP_CHOICES } from '../../plugin/manifest';
 import { tryToNumber } from '../../common/typescript';
 import { Checkbox } from 'primereact/checkbox';
 
 export interface OptionsWidgetProps
-    extends Omit<TableRenderOptions, 'scrollingBehavior' | 'effectiveAddressLength'>,
-    Required<DebugProtocol.ReadMemoryArguments> {
+    extends Omit<TableRenderOptions, 'scrollingBehavior' | 'effectiveAddressLength'> {
+    configuredReadArguments: Required<DebugProtocol.ReadMemoryArguments>;
+    activeReadArguments: Required<DebugProtocol.ReadMemoryArguments>;
     title: string;
     updateRenderOptions: (options: Partial<SerializedTableRenderOptions>) => void;
     resetRenderOptions: () => void;
     updateTitle: (title: string) => void;
-    updateMemoryArguments: (
-        memoryArguments: Partial<DebugProtocol.ReadMemoryArguments>
-    ) => void;
-    refreshMemory: () => void;
+    updateMemoryState: (state: Partial<MemoryState>) => void;
+    fetchMemory(partialOptions?: Partial<DebugProtocol.ReadMemoryArguments>): Promise<void>
     toggleColumn(id: string, isVisible: boolean): void;
     toggleFrozen: () => void;
     isFrozen: boolean;
@@ -74,9 +73,9 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
 
     protected get optionsFormValues(): OptionsForm {
         return {
-            address: this.props.memoryReference,
-            offset: this.props.offset.toString(),
-            count: this.props.count.toString(),
+            address: this.props.configuredReadArguments.memoryReference,
+            offset: this.props.configuredReadArguments.offset.toString(),
+            count: this.props.configuredReadArguments.count.toString(),
         };
     }
 
@@ -88,7 +87,7 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
             enableReinitialize: true,
             validate: this.validate,
             onSubmit: () => {
-                this.props.refreshMemory();
+                this.props.fetchMemory(this.props.configuredReadArguments);
             },
         };
         this.state = { isTitleEditing: false };
@@ -141,6 +140,11 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
         const isLabelEditing = this.state.isTitleEditing;
         const isFrozen = this.props.isFrozen;
         const freezeContentToggleTitle = isFrozen ? 'Unfreeze Memory View' : 'Freeze Memory View';
+        const activeMemoryReadArgumentHint = (userValue: string | number, memoryValue: string | number): ReactNode | undefined => {
+            if (userValue !== memoryValue) {
+                return <small className="form-options-memory-read-argument-hint">Actual: {memoryValue}</small>;
+            }
+        };
 
         return (
             <div className='memory-options-widget px-4'>
@@ -182,7 +186,7 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
                     <Formik {...this.formConfig} >
                         {formik => (
                             <form onSubmit={formik.handleSubmit} className='form-options'>
-                                <span className={'pm-top-label form-texfield-long'}>
+                                <span className={'pm-top-label form-textfield form-texfield-long'}>
                                     <label htmlFor={InputId.Address} className={`p-inputtext-label ${isFrozen ? 'p-disabled' : ''}`} >
                                         Address
                                     </label>
@@ -199,6 +203,7 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
                                             {formik.errors.address}
                                         </small>)
                                         : undefined}
+                                    {activeMemoryReadArgumentHint(this.props.configuredReadArguments.memoryReference, this.props.activeReadArguments.memoryReference)}
                                 </span>
                                 <span className='pm-top-label form-textfield'>
                                     <label htmlFor={InputId.Offset} className={`p-inputtext-label ${isFrozen ? 'p-disabled' : ''}`}>
@@ -217,6 +222,7 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
                                             {formik.errors.offset}
                                         </small>)
                                         : undefined}
+                                    {activeMemoryReadArgumentHint(this.props.configuredReadArguments.offset, this.props.activeReadArguments.offset)}
                                 </span>
                                 <span className='pm-top-label form-textfield'>
                                     <label htmlFor={InputId.Length} className={`p-inputtext-label ${isFrozen ? 'p-disabled' : ''}`}>
@@ -235,6 +241,7 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
                                             {formik.errors.count}
                                         </small>)
                                         : undefined}
+                                    {activeMemoryReadArgumentHint(this.props.configuredReadArguments.count, this.props.activeReadArguments.count)}
                                 </span>
                                 <Button type='submit' disabled={!formik.isValid || isFrozen}>
                                     Go
@@ -391,21 +398,30 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
     protected updateOptions(id: InputId, value: string): void {
         switch (id) {
             case InputId.Address:
-                this.props.updateMemoryArguments({
-                    memoryReference: value,
+                this.props.updateMemoryState({
+                    configuredReadArguments: {
+                        ...this.props.configuredReadArguments,
+                        memoryReference: value,
+                    }
                 });
                 break;
             case InputId.Offset:
                 if (!Number.isNaN(value)) {
-                    this.props.updateMemoryArguments({
-                        offset: Number(value),
+                    this.props.updateMemoryState({
+                        configuredReadArguments: {
+                            ...this.props.configuredReadArguments,
+                            offset: Number(value),
+                        }
                     });
                 }
                 break;
             case InputId.Length:
                 if (!Number.isNaN(value)) {
-                    this.props.updateMemoryArguments({
-                        count: Number(value),
+                    this.props.updateMemoryState({
+                        configuredReadArguments: {
+                            ...this.props.configuredReadArguments,
+                            count: Number(value),
+                        }
                     });
                 }
                 break;
diff --git a/src/webview/memory-webview-view.tsx b/src/webview/memory-webview-view.tsx
index 160e4fe..fce52aa 100644
--- a/src/webview/memory-webview-view.tsx
+++ b/src/webview/memory-webview-view.tsx
@@ -57,6 +57,11 @@ const MEMORY_DISPLAY_CONFIGURATION_DEFAULTS: MemoryDisplayConfiguration = {
     addressRadix: 16,
     showRadixPrefix: true,
 };
+const DEFAULT_READ_ARGUMENTS: Required<DebugProtocol.ReadMemoryArguments> = {
+    memoryReference: '',
+    offset: 0,
+    count: 256,
+};
 
 class App extends React.Component<{}, MemoryAppState> {
 
@@ -70,10 +75,9 @@ class App extends React.Component<{}, MemoryAppState> {
         this.state = {
             title: 'Memory',
             memory: undefined,
-            memoryReference: '',
-            offset: 0,
-            count: 256,
             effectiveAddressLength: 0,
+            configuredReadArguments: DEFAULT_READ_ARGUMENTS,
+            activeReadArguments: DEFAULT_READ_ARGUMENTS,
             decorations: [],
             columns: columnContributionService.getColumns(),
             isMemoryFetching: false,
@@ -110,19 +114,17 @@ class App extends React.Component<{}, MemoryAppState> {
     public render(): React.ReactNode {
         return <PrimeReactProvider>
             <MemoryWidget
+                configuredReadArguments={this.state.configuredReadArguments}
+                activeReadArguments={this.state.activeReadArguments}
                 memory={this.state.memory}
                 decorations={this.state.decorations}
                 columns={this.state.columns}
-                memoryReference={this.state.memoryReference}
-                offset={this.state.offset ?? 0}
-                count={this.state.count}
                 title={this.state.title}
                 effectiveAddressLength={this.state.effectiveAddressLength}
-                updateMemoryArguments={this.updateMemoryState}
+                updateMemoryState={this.updateMemoryState}
                 updateMemoryDisplayConfiguration={this.updateMemoryDisplayConfiguration}
                 resetMemoryDisplayConfiguration={this.resetMemoryDisplayConfiguration}
                 updateTitle={this.updateTitle}
-                refreshMemory={this.refreshMemory}
                 toggleColumn={this.toggleColumn}
                 toggleFrozen={this.toggleFrozen}
                 isFrozen={this.state.isFrozen}
@@ -149,12 +151,14 @@ class App extends React.Component<{}, MemoryAppState> {
 
     protected async setOptions(options?: Partial<DebugProtocol.ReadMemoryArguments>): Promise<void> {
         messenger.sendRequest(logMessageType, HOST_EXTENSION, `Setting options: ${JSON.stringify(options)}`);
-        this.setState(prevState => ({ ...prevState, ...options }));
+        if (this.state.configuredReadArguments.memoryReference === '') {
+            // Only update if we have no user configured read arguments
+            this.setState(prevState => ({ ...prevState, configuredReadArguments: { ...this.state.configuredReadArguments, ...options } }));
+        }
+
         return this.fetchMemory(options);
     }
 
-    protected refreshMemory = () => { this.fetchMemory(); };
-
     protected fetchMemory = async (partialOptions?: Partial<DebugProtocol.ReadMemoryArguments>): Promise<void> => this.doFetchMemory(partialOptions);
     protected async doFetchMemory(partialOptions?: Partial<DebugProtocol.ReadMemoryArguments>): Promise<void> {
         if (this.state.isFrozen) {
@@ -162,9 +166,9 @@ class App extends React.Component<{}, MemoryAppState> {
         }
         this.setState(prev => ({ ...prev, isMemoryFetching: true }));
         const completeOptions = {
-            memoryReference: partialOptions?.memoryReference || this.state.memoryReference,
-            offset: partialOptions?.offset ?? this.state.offset,
-            count: partialOptions?.count ?? this.state.count
+            memoryReference: partialOptions?.memoryReference || this.state.activeReadArguments.memoryReference,
+            offset: partialOptions?.offset ?? this.state.activeReadArguments.offset,
+            count: partialOptions?.count ?? this.state.activeReadArguments.count
         };
 
         try {
@@ -174,26 +178,39 @@ class App extends React.Component<{}, MemoryAppState> {
                 executor => executor.fetchData(completeOptions)
             ));
 
-            const memory = this.convertMemory(response);
-
-            this.setState({
+            const memory = this.convertMemory(completeOptions, response);
+            this.setState(prev => ({
+                ...prev,
                 decorations: decorationService.decorations,
                 memory,
-                memoryReference: completeOptions.memoryReference,
-                offset: completeOptions.offset,
-                count: completeOptions.count,
+                activeReadArguments: completeOptions,
                 isMemoryFetching: false
-            });
+            }));
 
             messenger.sendRequest(setOptionsType, HOST_EXTENSION, completeOptions);
+        } catch (ex) {
+            // Do not show old results if the current search provided no memory
+            this.setState(prev => ({
+                ...prev,
+                memory: undefined,
+                activeReadArguments: completeOptions,
+            }));
+
+            if (ex instanceof Error) {
+                console.error(ex);
+            }
         } finally {
             this.setState(prev => ({ ...prev, isMemoryFetching: false }));
         }
 
     }
 
-    protected convertMemory(result: DebugProtocol.ReadMemoryResponse['body']): Memory {
-        if (!result?.data) { throw new Error('No memory provided!'); }
+    protected convertMemory(request: Required<DebugProtocol.ReadMemoryArguments>, result: DebugProtocol.ReadMemoryResponse['body']): Memory {
+        if (!result?.data) {
+            const message = `No memory provided for address ${request.memoryReference}`
+                + `, offset ${request.offset} and count ${request.count}!`;
+            throw new Error(message);
+        }
         const address = BigInt(result.address);
         const bytes = Uint8Array.from(Buffer.from(result.data, 'base64'));
         return { bytes, address };
diff --git a/src/webview/utils/view-types.ts b/src/webview/utils/view-types.ts
index 6bfa8c6..ca45482 100644
--- a/src/webview/utils/view-types.ts
+++ b/src/webview/utils/view-types.ts
@@ -54,7 +54,15 @@ export function areDecorationsEqual(one: Decoration, other: Decoration): boolean
     return areRangesEqual(one.range, other.range) && deepequal(one.style, other.style);
 }
 
-export interface MemoryState extends DebugProtocol.ReadMemoryArguments {
+export interface MemoryState {
+    /**
+     * The user configured memory read arguments
+     */
+    configuredReadArguments: Required<DebugProtocol.ReadMemoryArguments>;
+    /**
+     * The active memory read arguments used to load the memory
+     */
+    activeReadArguments: Required<DebugProtocol.ReadMemoryArguments>;
     memory?: Memory;
     isMemoryFetching: boolean;
 }
@@ -88,7 +96,7 @@ export interface MemoryDisplayConfiguration {
     addressRadix: Radix;
     showRadixPrefix: boolean;
 }
-export type ScrollingBehavior = 'Paginate' | 'Infinite';
+export type ScrollingBehavior = 'Paginate' | 'Grow' | 'Auto-Append';
 
 export type AddressPadding = 'Min' | number;
 export const AddressPaddingOptions = {
diff --git a/src/webview/variables/variable-decorations.ts b/src/webview/variables/variable-decorations.ts
index d03c9cb..22f5c44 100644
--- a/src/webview/variables/variable-decorations.ts
+++ b/src/webview/variables/variable-decorations.ts
@@ -66,7 +66,7 @@ export class VariableDecorator implements ColumnContribution, Decorator {
     async activate(memory: MemoryState): Promise<void> {
         this.active = true;
         if (memory.memory?.bytes.length) {
-            await this.fetchData({ count: memory.count, offset: memory.offset, memoryReference: memory.memoryReference, });
+            await this.fetchData(memory.activeReadArguments);
         }
     }