diff --git a/addons/addon-image/test/ImageAddon.test.ts b/addons/addon-image/test/ImageAddon.test.ts
index f4e54d7f2e..5153b3ab22 100644
--- a/addons/addon-image/test/ImageAddon.test.ts
+++ b/addons/addon-image/test/ImageAddon.test.ts
@@ -117,8 +117,8 @@ test.describe('ImageAddon', () => {
       );
     }
     // bufferline privates
-    strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._data instanceof Uint32Array'), true);
-    strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._extendedAttrs instanceof Object'), true);
+    strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._logicalLine._data instanceof Uint32Array'), true);
+    strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._logicalLine._extendedAttrs instanceof Object'), true);
     // inputhandler privates
     strictEqual(await ctx.page.evaluate('window.term._core._inputHandler._curAttrData.constructor.name'), '_AttributeData');
     strictEqual(await ctx.page.evaluate('window.term._core._inputHandler._parser.constructor.name'), 'EscapeSequenceParser');
diff --git a/addons/addon-search/src/DecorationManager.test.ts b/addons/addon-search/src/DecorationManager.test.ts
index 26e40dbc20..de56c69fc9 100644
--- a/addons/addon-search/src/DecorationManager.test.ts
+++ b/addons/addon-search/src/DecorationManager.test.ts
@@ -6,7 +6,6 @@
 import { assert } from 'chai';
 import { DecorationManager } from './DecorationManager';
 import { SearchEngine } from './SearchEngine';
-import { SearchLineCache } from './SearchLineCache';
 import { Terminal } from 'browser/public/Terminal';
 import type { ISearchDecorationOptions } from '@xterm/addon-search';
 import type { IDecorationOptions } from '@xterm/xterm';
@@ -29,7 +28,7 @@ describe('DecorationManager', () => {
 
   it('should split highlight decorations for a wrapped match', async () => {
     await writeP(terminal, '0123456789abcde');
-    const searchEngine = new SearchEngine(terminal, store.add(new SearchLineCache(terminal)));
+    const searchEngine = new SearchEngine(terminal);
     const match = searchEngine.find('9abc', 0, 0);
     assert.ok(match);
 
diff --git a/addons/addon-search/src/SearchAddon.ts b/addons/addon-search/src/SearchAddon.ts
index e5fd31cfb0..a7ce7cc588 100644
--- a/addons/addon-search/src/SearchAddon.ts
+++ b/addons/addon-search/src/SearchAddon.ts
@@ -8,7 +8,6 @@ import type { SearchAddon as ISearchApi, ISearchOptions, ISearchAddonOptions, IS
 import { Emitter, type IEvent } from 'common/Event';
 import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
 import { disposableTimeout } from 'common/Async';
-import { SearchLineCache } from './SearchLineCache';
 import { SearchState } from './SearchState';
 import { SearchEngine, type ISearchResult } from './SearchEngine';
 import { DecorationManager } from './DecorationManager';
@@ -34,7 +33,6 @@ export class SearchAddon extends Disposable implements ITerminalAddon, ISearchAp
   private _terminal: Terminal | undefined;
   private _highlightLimit: number;
   private _highlightTimeout = this._register(new MutableDisposable<IDisposable>());
-  private _lineCache = this._register(new MutableDisposable<SearchLineCache>());
 
   // Component instances
   private _state = new SearchState();
@@ -59,8 +57,7 @@ export class SearchAddon extends Disposable implements ITerminalAddon, ISearchAp
 
   public activate(terminal: Terminal): void {
     this._terminal = terminal;
-    this._lineCache.value = new SearchLineCache(terminal);
-    this._engine = new SearchEngine(terminal, this._lineCache.value);
+    this._engine = new SearchEngine(terminal);
     this._decorationManager = new DecorationManager(terminal);
     this._register(this._terminal.onWriteParsed(() => this._updateMatches()));
     this._register(this._terminal.onResize(() => this._updateMatches()));
diff --git a/addons/addon-search/src/SearchEngine.test.ts b/addons/addon-search/src/SearchEngine.test.ts
index b3cea8f54f..3b07352869 100644
--- a/addons/addon-search/src/SearchEngine.test.ts
+++ b/addons/addon-search/src/SearchEngine.test.ts
@@ -4,7 +4,6 @@
  */
 import { assert } from 'chai';
 import { SearchEngine } from './SearchEngine';
-import { SearchLineCache } from './SearchLineCache';
 import { Terminal } from 'browser/public/Terminal';
 import type { ISearchOptions } from '@xterm/addon-search';
 import { DisposableStore } from 'common/Lifecycle';
@@ -16,14 +15,12 @@ function writeP(terminal: Terminal, data: string): Promise<void> {
 describe('SearchEngine', () => {
   let store: DisposableStore;
   let terminal: Terminal;
-  let lineCache: SearchLineCache;
   let searchEngine: SearchEngine;
 
   beforeEach(() => {
     store = new DisposableStore();
     terminal = store.add(new Terminal({ cols: 80, rows: 24 }));
-    lineCache = store.add(new SearchLineCache(terminal));
-    searchEngine = new SearchEngine(terminal, lineCache);
+    searchEngine = new SearchEngine(terminal);
   });
 
   afterEach(() => {
@@ -663,9 +660,6 @@ describe('SearchEngine', () => {
     it('should use cache for line translation', async () => {
       await writeP(terminal, 'Hello World');
 
-      // Initialize cache
-      lineCache.initLinesCache();
-
       const result1 = searchEngine.find('World', 0, 0);
       const result2 = searchEngine.find('World', 0, 0);
 
@@ -688,7 +682,6 @@ describe('SearchEngine', () => {
 
     it('should work correctly with cache invalidation', async () => {
       await writeP(terminal, 'Initial text');
-      lineCache.initLinesCache();
 
       const result1 = searchEngine.find('Initial', 0, 0);
       assert.notStrictEqual(result1, undefined);
diff --git a/addons/addon-search/src/SearchEngine.ts b/addons/addon-search/src/SearchEngine.ts
index 1760bc2bd1..62ccb4a0cd 100644
--- a/addons/addon-search/src/SearchEngine.ts
+++ b/addons/addon-search/src/SearchEngine.ts
@@ -5,7 +5,8 @@
 
 import type { Terminal } from '@xterm/xterm';
 import type { ISearchOptions } from '@xterm/addon-search';
-import type { SearchLineCache } from './SearchLineCache';
+import { CellData } from 'common/buffer/CellData';
+import type { ITerminal } from 'browser/Types';
 
 /**
  * Represents the position to start a search from.
@@ -43,9 +44,11 @@ const enum Constants {
  */
 export class SearchEngine {
   constructor(
-    private readonly _terminal: Terminal,
-    private readonly _lineCache: SearchLineCache
-  ) {}
+    private readonly _terminal: Terminal
+  ) {
+    this._core = (this._terminal as any)._core;
+  }
+  private _core: ITerminal;
 
   /**
    * Find the first occurrence of a term starting from a specific position.
@@ -64,8 +67,6 @@ export class SearchEngine {
       throw new Error(`Invalid col: ${startCol} to search in terminal of ${this._terminal.cols} cols`);
     }
 
-    this._lineCache.initLinesCache();
-
     const searchPosition: ISearchPosition = {
       startRow,
       startCol
@@ -115,8 +116,6 @@ export class SearchEngine {
       }
     }
 
-    this._lineCache.initLinesCache();
-
     const searchPosition: ISearchPosition = {
       startRow,
       startCol
@@ -177,7 +176,6 @@ export class SearchEngine {
     const startCol = this._terminal.cols;
     const isReverseSearch = true;
 
-    this._lineCache.initLinesCache();
     const searchPosition: ISearchPosition = {
       startRow,
       startCol
@@ -250,11 +248,11 @@ export class SearchEngine {
    * @returns The search result if it was found.
    */
   private _findInLine(term: string, searchPosition: ISearchPosition, searchOptions: ISearchOptions = {}, isReverseSearch: boolean = false): ISearchResult | undefined {
-    const row = searchPosition.startRow;
-    const col = searchPosition.startCol;
+    let row = searchPosition.startRow;
+    let col = searchPosition.startCol;
 
     // Ignore wrapped lines, only consider on unwrapped line (first row of command string).
-    const firstLine = this._terminal.buffer.active.getLine(row);
+    let firstLine = this._core.buffer.lines.get(row);
     if (firstLine?.isWrapped) {
       if (isReverseSearch) {
         searchPosition.startCol += this._terminal.cols;
@@ -263,16 +261,16 @@ export class SearchEngine {
 
       // This will iterate until we find the line start.
       // When we find it, we will search using the calculated start column.
-      searchPosition.startRow--;
-      searchPosition.startCol += this._terminal.cols;
-      return this._findInLine(term, searchPosition, searchOptions);
-    }
-    let cache = this._lineCache.getLineFromCache(row);
-    if (!cache) {
-      cache = this._lineCache.translateBufferLineToStringWithWrap(row, true);
-      this._lineCache.setLineInCache(row, cache);
+      do {
+        row--;
+        col += this._terminal.cols;
+        firstLine = this._core.buffer.lines.get(row);
+      } while (firstLine?.isWrapped);
+      searchPosition.startRow = row;
+      searchPosition.startCol = col;
     }
-    const [stringLine, offsets] = cache;
+    const logical = firstLine?.logical();
+    const stringLine = logical ? logical.asString() : '';
 
     const offset = this._bufferColsToStringOffset(row, col);
     let searchTerm = term;
@@ -314,6 +312,10 @@ export class SearchEngine {
       if (searchOptions.wholeWord && !this._isWholeWord(resultIndex, searchStringLine, term)) {
         return;
       }
+      const offsets: number[] = [];
+      logical?.forEachBufferLine((line) => {
+        offsets.push(logical.offsetInString(line.startColumn));
+      });
 
       // Adjust the row number and search index if needed since a "line" of text can span multiple
       // rows
@@ -341,12 +343,13 @@ export class SearchEngine {
   }
 
   private _stringLengthToBufferSize(row: number, offset: number): number {
-    const line = this._terminal.buffer.active.getLine(row);
+    const line = this._core.buffer.lines.get(row);
     if (!line) {
       return 0;
     }
+    const cell = new CellData();
     for (let i = 0; i < offset; i++) {
-      const cell = line.getCell(i);
+      line.loadCell(i, cell);
       if (!cell) {
         break;
       }
@@ -355,38 +358,14 @@ export class SearchEngine {
       if (char.length > 1) {
         offset -= char.length - 1;
       }
-      // Adjust the searchIndex for empty characters following wide unicode
-      // chars (eg. CJK)
-      const nextCell = line.getCell(i + 1);
-      if (nextCell && nextCell.getWidth() === 0) {
-        offset++;
-      }
+      const width = cell.getWidth();
+      if (width > 1) { offset += width - 1; }
     }
     return offset;
   }
 
   private _bufferColsToStringOffset(startRow: number, cols: number): number {
-    let lineIndex = startRow;
-    let offset = 0;
-    let line = this._terminal.buffer.active.getLine(lineIndex);
-    while (cols > 0 && line) {
-      for (let i = 0; i < cols && i < this._terminal.cols; i++) {
-        const cell = line.getCell(i);
-        if (!cell) {
-          break;
-        }
-        if (cell.getWidth()) {
-          // Treat null characters as whitespace to align with the translateToString API
-          offset += cell.getCode() === 0 ? 1 : cell.getChars().length;
-        }
-      }
-      lineIndex++;
-      line = this._terminal.buffer.active.getLine(lineIndex);
-      if (line && !line.isWrapped) {
-        break;
-      }
-      cols -= this._terminal.cols;
-    }
-    return offset;
+    const line = this._core.buffer.lines.get(startRow)!;
+    return line ? line.logical().offsetInString(cols) : 0;
   }
 }
diff --git a/addons/addon-search/src/SearchLineCache.test.ts b/addons/addon-search/src/SearchLineCache.test.ts
deleted file mode 100644
index 77f64c81ec..0000000000
--- a/addons/addon-search/src/SearchLineCache.test.ts
+++ /dev/null
@@ -1,287 +0,0 @@
-/**
- * Copyright (c) 2024 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-import { assert } from 'chai';
-import { SearchLineCache, LineCacheEntry } from './SearchLineCache';
-import { Terminal } from 'browser/public/Terminal';
-import { timeout } from 'common/Async';
-
-function writeP(terminal: Terminal, data: string): Promise<void> {
-  return new Promise(r => terminal.write(data, r));
-}
-
-describe('SearchLineCache', () => {
-  let terminal: Terminal;
-  let cache: SearchLineCache;
-
-  beforeEach(() => {
-    terminal = new Terminal({ cols: 80, rows: 24 });
-    cache = new SearchLineCache(terminal);
-  });
-
-  afterEach(() => {
-    cache.dispose();
-    terminal.dispose();
-  });
-
-  describe('constructor', () => {
-    it('should create a SearchLineCache instance', () => {
-      assert.instanceOf(cache, SearchLineCache);
-    });
-
-    it('should start with no cache initialized', () => {
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-  });
-
-  describe('initLinesCache', () => {
-    it('should initialize the lines cache array', () => {
-      cache.initLinesCache();
-      assert.equal(cache.getLineFromCache(0), undefined, 'cache should be initialized but empty');
-    });
-
-    it('should not reinitialize if cache already exists', () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      cache.initLinesCache();
-
-      const entry = cache.getLineFromCache(0);
-      assert.deepEqual(entry, ['test', [0]], 'cache should still contain the previously set entry');
-    });
-
-    it('should set up TTL timeout', () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      assert.deepEqual(cache.getLineFromCache(0), ['test', [0]], 'entry should exist after initialization');
-    });
-  });
-
-  describe('getLineFromCache', () => {
-    it('should return undefined when cache is not initialized', () => {
-      assert.equal(cache.getLineFromCache(0), undefined);
-      assert.equal(cache.getLineFromCache(10), undefined);
-    });
-
-    it('should return undefined for unset entries when cache is initialized', () => {
-      cache.initLinesCache();
-      assert.equal(cache.getLineFromCache(0), undefined);
-      assert.equal(cache.getLineFromCache(50), undefined);
-    });
-
-    it('should return cached entries', () => {
-      cache.initLinesCache();
-      const entry: LineCacheEntry = ['test content', [0]];
-      cache.setLineInCache(5, entry);
-
-      assert.deepEqual(cache.getLineFromCache(5), entry);
-    });
-  });
-
-  describe('setLineInCache', () => {
-    it('should not set entries when cache is not initialized', () => {
-      const entry: LineCacheEntry = ['test content', [0]];
-      cache.setLineInCache(0, entry);
-
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-
-    it('should set entries when cache is initialized', () => {
-      cache.initLinesCache();
-      const entry: LineCacheEntry = ['test content', [0]];
-      cache.setLineInCache(10, entry);
-
-      assert.deepEqual(cache.getLineFromCache(10), entry);
-    });
-
-    it('should overwrite existing entries', () => {
-      cache.initLinesCache();
-      const entry1: LineCacheEntry = ['first content', [0]];
-      const entry2: LineCacheEntry = ['second content', [0]];
-
-      cache.setLineInCache(0, entry1);
-      assert.deepEqual(cache.getLineFromCache(0), entry1);
-
-      cache.setLineInCache(0, entry2);
-      assert.deepEqual(cache.getLineFromCache(0), entry2);
-    });
-  });
-
-  describe('translateBufferLineToStringWithWrap', () => {
-    it('should translate a single line without wrapping', async () => {
-      await writeP(terminal, 'Hello World');
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.equal(result[0], 'Hello World');
-      assert.deepEqual(result[1], [0]);
-    });
-
-    it('should handle trimRight parameter', async () => {
-      await writeP(terminal, 'Hello World   ');
-      const resultTrimmed = cache.translateBufferLineToStringWithWrap(0, true);
-      const resultNotTrimmed = cache.translateBufferLineToStringWithWrap(0, false);
-
-      assert.equal(resultTrimmed[0].trimEnd(), 'Hello World');
-      assert.isTrue(resultNotTrimmed[0].startsWith('Hello World   '));
-      assert.isTrue(resultNotTrimmed[0].length > resultTrimmed[0].length, 'non-trimmed result should be longer');
-    });
-
-    it('should handle wrapped lines', async () => {
-      const longText = 'A'.repeat(200);
-      await writeP(terminal, longText);
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.equal(result[0], longText);
-      assert.isTrue(result[1].length > 1, 'should have multiple offsets due to wrapping');
-      assert.equal(result[1][0], 0, 'first offset should be 0');
-    });
-
-    it('should handle wide characters', async () => {
-      await writeP(terminal, 'Hello 世界');
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.equal(result[0], 'Hello 世界');
-      assert.deepEqual(result[1], [0]);
-    });
-
-    it('should handle empty lines', () => {
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.equal(result[0], '');
-      assert.deepEqual(result[1], [0]);
-    });
-
-    it('should handle lines beyond buffer', () => {
-      const result = cache.translateBufferLineToStringWithWrap(1000, true);
-      assert.equal(result[0], '');
-      assert.deepEqual(result[1], [0]);
-    });
-
-    it('should handle complex wrapped content', async () => {
-      await writeP(terminal, 'Line 1\r\n');
-      await writeP(terminal, 'Line 2 with some longer content that might wrap\r\n');
-      await writeP(terminal, 'Line 3');
-
-      const result1 = cache.translateBufferLineToStringWithWrap(0, true);
-      const result2 = cache.translateBufferLineToStringWithWrap(1, true);
-      const result3 = cache.translateBufferLineToStringWithWrap(2, true);
-
-      assert.equal(result1[0], 'Line 1');
-      assert.equal(result2[0], 'Line 2 with some longer content that might wrap');
-      assert.equal(result3[0], 'Line 3');
-    });
-  });
-
-  describe('cache invalidation', () => {
-    it('should invalidate cache on line feed', async () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      assert.deepEqual(cache.getLineFromCache(0), ['test', [0]]);
-
-      terminal.write('test\r\n');
-
-      await timeout(10);
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-
-    it('should invalidate cache on cursor move', async () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      assert.deepEqual(cache.getLineFromCache(0), ['test', [0]]);
-
-      await writeP(terminal, 'some text');
-      await timeout(10);
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-
-    it('should invalidate cache on resize', async () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      assert.deepEqual(cache.getLineFromCache(0), ['test', [0]]);
-
-      terminal.resize(100, 30);
-
-      await timeout(10);
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-  });
-
-  describe('disposal', () => {
-    it('should clean up resources on dispose', () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      assert.deepEqual(cache.getLineFromCache(0), ['test', [0]]);
-
-      cache.dispose();
-
-      assert.equal(cache.getLineFromCache(0), undefined, 'cache should be destroyed after disposal');
-    });
-
-    it('should be safe to dispose multiple times', () => {
-      cache.initLinesCache();
-      cache.dispose();
-      cache.dispose();
-
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-  });
-
-  describe('LineCacheEntry type', () => {
-    it('should handle complex line offsets', () => {
-      const entry: LineCacheEntry = [
-        'A very long line that wraps multiple times across several terminal lines',
-        [0, 20, 40, 60]
-      ];
-
-      cache.initLinesCache();
-      cache.setLineInCache(0, entry);
-
-      const retrieved = cache.getLineFromCache(0);
-      assert.deepEqual(retrieved, entry);
-      assert.equal(retrieved![0].length, 72);
-      assert.equal(retrieved![1].length, 4);
-    });
-
-    it('should handle unicode characters in cache entries', () => {
-      const entry: LineCacheEntry = [
-        'Hello 世界 🌍 测试',
-        [0]
-      ];
-
-      cache.initLinesCache();
-      cache.setLineInCache(0, entry);
-
-      const retrieved = cache.getLineFromCache(0);
-      assert.deepEqual(retrieved, entry);
-      assert.equal(retrieved![0], 'Hello 世界 🌍 测试');
-    });
-  });
-
-  describe('integration with real terminal content', () => {
-    it('should correctly translate real buffer content', async () => {
-      await writeP(terminal, 'Hello World');
-      const cached = cache.translateBufferLineToStringWithWrap(0, true);
-      const directTranslation = terminal.buffer.active.getLine(0)?.translateToString(true) || '';
-
-      assert.equal(cached[0], directTranslation);
-    });
-
-    it('should handle real wrapped content correctly', async () => {
-      const longContent = 'This is a very long line that will definitely wrap around in an 80 column terminal and should be handled correctly by the cache';
-      await writeP(terminal, longContent);
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.equal(result[0], longContent);
-      assert.isTrue(result[1].length > 1, 'should have wrapped');
-    });
-
-    it('should work with real escape sequences', async () => {
-      await writeP(terminal, 'Before\x1b[31mRed Text\x1b[0mAfter');
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.include(result[0], 'Before');
-      assert.include(result[0], 'Red Text');
-      assert.include(result[0], 'After');
-    });
-  });
-});
diff --git a/addons/addon-search/src/SearchLineCache.ts b/addons/addon-search/src/SearchLineCache.ts
deleted file mode 100644
index 526f4bfcc7..0000000000
--- a/addons/addon-search/src/SearchLineCache.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import type { Terminal } from '@xterm/xterm';
-import { combinedDisposable, Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
-import { disposableTimeout } from 'common/Async';
-
-export type LineCacheEntry = [
-  /**
-   * The string representation of a line (as opposed to the buffer cell representation).
-   */
-  lineAsString: string,
-  /**
-   * The offsets where each line starts when the entry describes a wrapped line.
-   */
-  lineOffsets: number[]
-];
-
-/**
- * Configuration constants for the search line cache functionality.
- */
-const enum Constants {
-  /**
-   * Time-to-live for cached search results in milliseconds. After this duration, cached search
-   * results will be invalidated to ensure they remain consistent with terminal content changes.
-   */
-  LINES_CACHE_TIME_TO_LIVE = 15000
-}
-
-export class SearchLineCache extends Disposable {
-  /**
-   * translateBufferLineToStringWithWrap is a fairly expensive call.
-   * We memoize the calls into an array that has a time based ttl.
-   * _linesCache is also invalidated when the terminal cursor moves.
-   */
-  private _linesCache: LineCacheEntry[] | undefined;
-  private _linesCacheTimeout = this._register(new MutableDisposable());
-  private _linesCacheDisposables = this._register(new MutableDisposable());
-  // Track access to avoid recreating a timeout on every init call which occurs once per search
-  // result (findNext/findPrevious -> _highlightAllMatches -> find loop).
-  private _lastAccessTimestamp = 0;
-
-  constructor(private readonly _terminal: Terminal) {
-    super();
-    this._register(toDisposable(() => this._destroyLinesCache()));
-  }
-
-  /**
-   * Sets up a line cache with a ttl
-   */
-  public initLinesCache(): void {
-    if (!this._linesCache) {
-      this._linesCache = new Array(this._terminal.buffer.active.length);
-      this._linesCacheDisposables.value = combinedDisposable(
-        this._terminal.onLineFeed(() => this._destroyLinesCache()),
-        this._terminal.onCursorMove(() => this._destroyLinesCache()),
-        this._terminal.onResize(() => this._destroyLinesCache())
-      );
-    }
-
-    this._lastAccessTimestamp = Date.now();
-    if (!this._linesCacheTimeout.value) {
-      this._scheduleLinesCacheTimeout(Constants.LINES_CACHE_TIME_TO_LIVE);
-    }
-  }
-
-  private _destroyLinesCache(): void {
-    this._linesCache = undefined;
-    this._lastAccessTimestamp = 0;
-    this._linesCacheDisposables.clear();
-    this._linesCacheTimeout.clear();
-  }
-
-  private _scheduleLinesCacheTimeout(delay: number): void {
-    this._linesCacheTimeout.value = disposableTimeout(() => {
-      if (!this._linesCache) {
-        return;
-      }
-      const now = Date.now();
-      const elapsed = now - this._lastAccessTimestamp;
-      if (elapsed >= Constants.LINES_CACHE_TIME_TO_LIVE) {
-        this._destroyLinesCache();
-        return;
-      }
-      this._scheduleLinesCacheTimeout(Constants.LINES_CACHE_TIME_TO_LIVE - elapsed);
-    }, delay);
-  }
-
-  public getLineFromCache(row: number): LineCacheEntry | undefined {
-    return this._linesCache?.[row];
-  }
-
-  public setLineInCache(row: number, entry: LineCacheEntry): void {
-    if (this._linesCache) {
-      this._linesCache[row] = entry;
-    }
-  }
-
-  /**
-   * Translates a buffer line to a string, including subsequent lines if they are wraps.
-   * Wide characters will count as two columns in the resulting string. This
-   * function is useful for getting the actual text underneath the raw selection
-   * position.
-   * @param lineIndex The index of the line being translated.
-   * @param trimRight Whether to trim whitespace to the right.
-   */
-  public translateBufferLineToStringWithWrap(lineIndex: number, trimRight: boolean): LineCacheEntry {
-    const strings = [];
-    const lineOffsets = [0];
-    let line = this._terminal.buffer.active.getLine(lineIndex);
-    while (line) {
-      const nextLine = this._terminal.buffer.active.getLine(lineIndex + 1);
-      const lineWrapsToNext = nextLine ? nextLine.isWrapped : false;
-      let string = line.translateToString(!lineWrapsToNext && trimRight);
-      if (lineWrapsToNext && nextLine) {
-        const lastCell = line.getCell(line.length - 1);
-        const lastCellIsNull = lastCell && lastCell.getCode() === 0 && lastCell.getWidth() === 1;
-        // a wide character wrapped to the next line
-        if (lastCellIsNull && nextLine.getCell(0)?.getWidth() === 2) {
-          string = string.slice(0, -1);
-        }
-      }
-      strings.push(string);
-      if (lineWrapsToNext) {
-        lineOffsets.push(lineOffsets[lineOffsets.length - 1] + string.length);
-      } else {
-        break;
-      }
-      lineIndex++;
-      line = nextLine;
-    }
-    return [strings.join(''), lineOffsets];
-  }
-}
diff --git a/addons/addon-serialize/test/SerializeAddon.test.ts b/addons/addon-serialize/test/SerializeAddon.test.ts
index f84452d58b..f93094d4e5 100644
--- a/addons/addon-serialize/test/SerializeAddon.test.ts
+++ b/addons/addon-serialize/test/SerializeAddon.test.ts
@@ -49,14 +49,20 @@ test.describe('SerializeAddon', () => {
         for (let i = 0; i < buffer.length; i++) {
           // Do this intentionally to get content of underlining source
           const bufferLine = buffer.getLine(i);
-          lines.push(JSON.stringify(bufferLine, (key, value) => {
-            // BufferLine caches are internal/transient and can legitimately differ
-            // across equivalent terminal states.
-            if (key === '_stringCache' || key === '_stringCacheEntryRef') {
-              return undefined;
-            }
-            return value;
-          }));
+          if (bufferLine.isWrapped) {
+            lines.push({ startColumn: bufferLine.startColumn, length: bufferLine.length});
+          } else {
+            const logical = bufferLine.logical();
+            lines.push(JSON.stringify(logical, (key, value) => {
+              if (key === 'firstBufferLine' ) {
+                return undefined;
+              }
+              if (key === '_data') {
+                return new Uint32Array(value.buffer, 0, logical.trimmedLength * 3);
+              }
+              return value
+            }));
+          }
         }
         return {
           x: buffer.cursorX,
diff --git a/src/browser/Terminal.test.ts b/src/browser/Terminal.test.ts
index a98ddf8659..1aca68725b 100644
--- a/src/browser/Terminal.test.ts
+++ b/src/browser/Terminal.test.ts
@@ -440,8 +440,8 @@ describe('Terminal', () => {
     describe('scroll() function', () => {
       describe('when scrollback > 0', () => {
         it('should create a new line and scroll', () => {
-          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 0));
-          term.buffer.lines.get(INIT_ROWS - 1)!.setCell(0, createCellData(0, 'b', 0));
+          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+          term.buffer.lines.get(INIT_ROWS - 1)!.setCell(0, createCellData(0, 'b', 1));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.scroll(DEFAULT_ATTR_DATA.clone());
           assert.equal(term.buffer.lines.length, INIT_ROWS + 1);
@@ -451,9 +451,9 @@ describe('Terminal', () => {
         });
 
         it('should properly scroll inside a scroll region (scrollTop set)', () => {
-          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 0));
-          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 0));
-          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 0));
+          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 1));
+          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 1));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.scroll(DEFAULT_ATTR_DATA.clone());
@@ -463,11 +463,11 @@ describe('Terminal', () => {
         });
 
         it('should properly scroll inside a scroll region (scrollBottom set)', () => {
-          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 0));
-          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 0));
-          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 0));
-          term.buffer.lines.get(3)!.setCell(0, createCellData(0, 'd', 0));
-          term.buffer.lines.get(4)!.setCell(0, createCellData(0, 'e', 0));
+          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 1));
+          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 1));
+          term.buffer.lines.get(3)!.setCell(0, createCellData(0, 'd', 1));
+          term.buffer.lines.get(4)!.setCell(0, createCellData(0, 'e', 1));
           term.buffer.y = 3;
           term.buffer.scrollBottom = 3;
           term.scroll(DEFAULT_ATTR_DATA.clone());
@@ -481,11 +481,11 @@ describe('Terminal', () => {
         });
 
         it('should properly scroll inside a scroll region (scrollTop and scrollBottom set)', () => {
-          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 0));
-          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 0));
-          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 0));
-          term.buffer.lines.get(3)!.setCell(0, createCellData(0, 'd', 0));
-          term.buffer.lines.get(4)!.setCell(0, createCellData(0, 'e', 0));
+          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 1));
+          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 1));
+          term.buffer.lines.get(3)!.setCell(0, createCellData(0, 'd', 1));
+          term.buffer.lines.get(4)!.setCell(0, createCellData(0, 'e', 1));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.buffer.scrollBottom = 3;
@@ -506,9 +506,9 @@ describe('Terminal', () => {
         });
 
         it('should create a new line and shift everything up', () => {
-          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 0));
-          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 0));
-          term.buffer.lines.get(INIT_ROWS - 1)!.setCell(0, createCellData(0, 'c', 0));
+          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 1));
+          term.buffer.lines.get(INIT_ROWS - 1)!.setCell(0, createCellData(0, 'c', 1));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           assert.equal(term.buffer.lines.length, INIT_ROWS);
           term.scroll(DEFAULT_ATTR_DATA.clone());
@@ -521,9 +521,9 @@ describe('Terminal', () => {
         });
 
         it('should properly scroll inside a scroll region (scrollTop set)', () => {
-          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 0));
-          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 0));
-          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 0));
+          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 1));
+          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 1));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.scroll(DEFAULT_ATTR_DATA.clone());
@@ -533,11 +533,11 @@ describe('Terminal', () => {
         });
 
         it('should properly scroll inside a scroll region (scrollBottom set)', () => {
-          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 0));
-          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 0));
-          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 0));
-          term.buffer.lines.get(3)!.setCell(0, createCellData(0, 'd', 0));
-          term.buffer.lines.get(4)!.setCell(0, createCellData(0, 'e', 0));
+          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 1));
+          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 1));
+          term.buffer.lines.get(3)!.setCell(0, createCellData(0, 'd', 1));
+          term.buffer.lines.get(4)!.setCell(0, createCellData(0, 'e', 1));
           term.buffer.y = 3;
           term.buffer.scrollBottom = 3;
           term.scroll(DEFAULT_ATTR_DATA.clone());
@@ -550,11 +550,11 @@ describe('Terminal', () => {
         });
 
         it('should properly scroll inside a scroll region (scrollTop and scrollBottom set)', () => {
-          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 0));
-          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 0));
-          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 0));
-          term.buffer.lines.get(3)!.setCell(0, createCellData(0, 'd', 0));
-          term.buffer.lines.get(4)!.setCell(0, createCellData(0, 'e', 0));
+          term.buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+          term.buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 1));
+          term.buffer.lines.get(2)!.setCell(0, createCellData(0, 'c', 1));
+          term.buffer.lines.get(3)!.setCell(0, createCellData(0, 'd', 1));
+          term.buffer.lines.get(4)!.setCell(0, createCellData(0, 'e', 1));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.buffer.scrollBottom = 3;
diff --git a/src/browser/TestUtils.test.ts b/src/browser/TestUtils.test.ts
index 27a13d4da0..f2ff58149f 100644
--- a/src/browser/TestUtils.test.ts
+++ b/src/browser/TestUtils.test.ts
@@ -11,6 +11,7 @@ import { IAttributeData, IBuffer, IBufferLine, IBufferSet, ICellData } from '../
 import { ICircularList } from '../common/CircularList';
 import { XtermListener, ICharset, ITerminalOptions, ColorIndex } from '../common/Types';
 import { Buffer } from '../common/buffer/Buffer';
+import { LogicalLine } from '../common/buffer/BufferLine';
 import * as Browser from '../common/Platform';
 import { CoreBrowserTerminal } from './CoreBrowserTerminal';
 import { IUnicodeService, IOptionsService, ICoreService, IMouseStateService } from '../common/services/Services';
@@ -256,8 +257,8 @@ export class MockBuffer implements IBuffer {
   public setLines(lines: ICircularList<IBufferLine>): void {
     this.lines = lines;
   }
-  public getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine {
-    return Buffer.prototype.getBlankLine.apply(this, arguments as any);
+  public getBlankLine(attr: IAttributeData, logicalLine?: LogicalLine): IBufferLine {
+    return Buffer.prototype.getBlankLine(attr, logicalLine);
   }
   public getNullCell(attr?: IAttributeData): ICellData {
     throw new Error('Method not implemented.');
diff --git a/src/browser/renderer/dom/DomRendererRowFactory.test.ts b/src/browser/renderer/dom/DomRendererRowFactory.test.ts
index e19f6852ac..0e6ff554c0 100644
--- a/src/browser/renderer/dom/DomRendererRowFactory.test.ts
+++ b/src/browser/renderer/dom/DomRendererRowFactory.test.ts
@@ -6,11 +6,11 @@
 import jsdom = require('jsdom');
 import { assert } from 'chai';
 import { DomRendererRowFactory } from './DomRendererRowFactory';
-import { DEFAULT_ATTR, FgFlags, BgFlags, Attributes, UnderlineStyle } from '../../../common/buffer/Constants';
+import { FgFlags, BgFlags, Attributes, UnderlineStyle, NULL_CELL_CHAR } from '../../../common/buffer/Constants';
 import { BufferLine, DEFAULT_ATTR_DATA } from '../../../common/buffer/BufferLine';
 import { IBufferLine } from '../../../common/buffer/Types';
 import { CellData } from '../../../common/buffer/CellData';
-import { MockCoreService, MockDecorationService, MockOptionsService, createCellData, NULL_CELL_DATA } from '../../../common/TestUtils.test';
+import { MockCoreService, MockDecorationService, MockOptionsService, createCellData, NULL_CELL_DATA, DEFAULT_ATTR } from '../../../common/TestUtils.test';
 import { MockCharacterJoinerService, MockCoreBrowserService, MockThemeService } from '../../TestUtils.test';
 import { TestWidthCache } from './WidthCache.test';
 
@@ -347,6 +347,7 @@ describe('DomRendererRowFactory', () => {
       });
       it('should force whitespace cells to be rendered above the background', () => {
         lineData.setCell(1, createCellData(DEFAULT_ATTR, 'a', 1));
+        lineData.setCell(0, createCellData(DEFAULT_ATTR, ' ', 1));
         rowFactory.handleSelectionChanged([0, 0], [2, 0], false);
         const spans = rowFactory.createRow(lineData, 0, false, undefined, undefined, 0, false, true, 5, widthCache, -1, -1);
         assert.equal(extractHtml(spans),
@@ -490,6 +491,7 @@ describe('DomRendererRowFactory', () => {
       lineData.setCell(1, createCellData(DEFAULT_ATTR, 'a', 1));
       lineData.setCell(2, createCellData(DEFAULT_ATTR, 'x', 1));
       lineData.setCell(4, createCellData(DEFAULT_ATTR, 'x', 1));
+      lineData.setCell(3, createCellData(DEFAULT_ATTR, NULL_CELL_CHAR, 1));
       const spans = rowFactory.createRow(lineData, 0, false, undefined, undefined, 0, false, true, 5, widthCache, 2, 4);
       assert.equal(extractHtml(spans),
         '<span>aa</span><span style="text-decoration: underline;">x x</span>'
diff --git a/src/common/InputHandler.test.ts b/src/common/InputHandler.test.ts
index 3534ff5abf..11bf42890b 100644
--- a/src/common/InputHandler.test.ts
+++ b/src/common/InputHandler.test.ts
@@ -461,8 +461,10 @@ describe('InputHandler', () => {
       await resetToBaseState();
       bufferService.buffer.y = 2;
       bufferService.buffer.x = 40;
-      inputHandler.eraseInLine(Params.fromArray([0]));
       assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);
+      assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, true);
+      inputHandler.eraseInLine(Params.fromArray([0]));
+      assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, false);
       bufferService.buffer.y = 2;
       bufferService.buffer.x = 0;
       inputHandler.eraseInLine(Params.fromArray([0]));
@@ -473,7 +475,8 @@ describe('InputHandler', () => {
       bufferService.buffer.y = 2;
       bufferService.buffer.x = 40;
       inputHandler.eraseInLine(Params.fromArray([1]));
-      assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);
+      assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false);
+      assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, true);
 
       // params[2] - erase complete line
       await resetToBaseState();
@@ -481,6 +484,7 @@ describe('InputHandler', () => {
       bufferService.buffer.x = 40;
       inputHandler.eraseInLine(Params.fromArray([2]));
       assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false);
+      assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, false);
     });
     it('ED2 with scrollOnEraseInDisplay turned on', async () => {
       const inputHandler = new TestInputHandler(
@@ -1863,6 +1867,8 @@ describe('InputHandler', () => {
         await inputHandler.parseP('\x1b[?45h');
         await inputHandler.parseP('￥￥￥');
         assert.deepEqual(getLines(bufferService, 2), ['￥￥', '￥']);
+        assert.equal(bufferService.buffer.lines.get(0)?.logical().asString(), '￥￥￥');
+        assert.equal(bufferService.buffer.lines.get(1)?.startColumn, 4);
         await inputHandler.parseP(ttyBS);
         assert.deepEqual(getLines(bufferService, 2), ['￥￥', '  ']);
         assert.equal(bufferService.buffer.x, 1);
diff --git a/src/common/InputHandler.ts b/src/common/InputHandler.ts
index 30657812f4..64dfaaa8ee 100644
--- a/src/common/InputHandler.ts
+++ b/src/common/InputHandler.ts
@@ -15,6 +15,7 @@ import { BufferLine, DEFAULT_ATTR_DATA } from './buffer/BufferLine';
 import { IParsingState, IEscapeSequenceParser, IParams, IFunctionIdentifier } from './parser/Types';
 import { NULL_CELL_CODE, NULL_CELL_WIDTH, Attributes, FgFlags, BgFlags, Content, UnderlineStyle } from './buffer/Constants';
 import { CellData } from './buffer/CellData';
+import { Buffer } from './buffer/Buffer';
 import { AttributeData } from './buffer/AttributeData';
 import { ICoreService, IBufferService, IOptionsService, ILogService, IMouseStateService, ICharsetService, IUnicodeService, LogLevelEnum, IOscLinkService } from './services/Services';
 import { UnicodeService } from './services/UnicodeService';
@@ -514,20 +515,25 @@ export class InputHandler extends Disposable implements IInputHandler {
     }
   }
 
+  /**
+   * Write printable characters.
+   * Character to write are code points stored in data.slice(start, end).
+   * Note that data.slice(start, end) might be modified in place.
+   */
   public print(data: Uint32Array, start: number, end: number): void {
     let code: number;
-    let chWidth: number;
     const charset = this._charsetService.charset;
     const screenReaderMode = this._optionsService.rawOptions.screenReaderMode;
     const cols = this._bufferService.cols;
     const wraparoundMode = this._coreService.decPrivateModes.wraparound;
     const insertMode = this._coreService.modes.insertMode;
+    const buffer = this._activeBuffer as Buffer;
     const curAttr = this._curAttrData;
     let bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y);
 
     // Defensive check: bufferRow can be undefined if a resize occurred mid-write due to async
     // scheduling gaps in WriteBuffer. See https://github.com/xtermjs/xterm.js/issues/5597
-    if (!bufferRow) {
+    if (!(bufferRow instanceof BufferLine)) {
       return;
     }
 
@@ -539,48 +545,86 @@ export class InputHandler extends Disposable implements IInputHandler {
     }
 
     let precedingJoinState = this._parser.precedingJoinState;
-    for (let pos = start; pos < end; ++pos) {
-      code = data[pos];
+    const linkId = this._getCurrentLinkId();
+    let pendingStart = -1;
+    let pendingCols = 0;
+    for (let pos = start; ; ++pos) {
+      let oldWidth;
+      let chWidth;
+      let shouldJoin;
+      let overflowing;
+      if (pos < end) {
+        code = data[pos];
+
+        // Soft hyphen's (U+00AD) behavior is ambiguous and differs across terminals.
+        // We opt to treat it as a zero-width hint to text layout engines and simply ignore it.
+        if (code === 0xAD) {
+          // Not very efficient, but simple.
+          pendingStart < 0 || data.copyWithin(pos, pos + 1, end);
+          continue;
+        }
 
-      // Soft hyphen's (U+00AD) behavior is ambiguous and differs across terminals. We opt to treat
-      // it as a zero-width hint to text layout engines and simply ignore it.
-      if (code === 0xAD) {
-        continue;
-      }
+        // get charset replacement character
+        // charset is only defined for ASCII, therefore we only
+        // search for an replacement char if code < 127
+        if (code < 127 && charset) {
+          const ch = charset[String.fromCharCode(code)];
+          if (ch) {
+            code = ch.charCodeAt(0);
+            data[pos] = code;
+          }
+        }
+
+        const currentInfo = this._unicodeService.charProperties(code, precedingJoinState);
+        chWidth = UnicodeService.extractWidth(currentInfo);
+        shouldJoin = UnicodeService.extractShouldJoin(currentInfo);
+        oldWidth = shouldJoin ? UnicodeService.extractWidth(precedingJoinState) : 0;
+        precedingJoinState = currentInfo;
 
-      // get charset replacement character
-      // charset is only defined for ASCII, therefore we only
-      // search for an replacement char if code < 127
-      if (code < 127 && charset) {
-        const ch = charset[String.fromCharCode(code)];
-        if (ch) {
-          code = ch.charCodeAt(0);
+        if (screenReaderMode) {
+          this._onA11yChar.fire(stringFromCodePoint(code));
         }
+        overflowing = this._activeBuffer.x + chWidth - oldWidth > cols;
+      } else {
+        oldWidth = 0;
+        chWidth = 0;
+        code = -1;
+        shouldJoin = false;
       }
+      if (pendingStart >= 0 && (code < 0 || overflowing || shouldJoin)) {
+        if (linkId) {
+          this._oscLinkService.addLineToLink(linkId, this._activeBuffer.ybase + this._activeBuffer.y);
+        }
 
-      const currentInfo = this._unicodeService.charProperties(code, precedingJoinState);
-      chWidth = UnicodeService.extractWidth(currentInfo);
-      const shouldJoin = UnicodeService.extractShouldJoin(currentInfo);
-      const oldWidth = shouldJoin ? UnicodeService.extractWidth(precedingJoinState) : 0;
-      precedingJoinState = currentInfo;
-
-      if (screenReaderMode) {
-        this._onA11yChar.fire(stringFromCodePoint(code));
+        // insert mode: move characters to right
+        if (insertMode) {
+          // right shift cells according to the width
+          bufferRow.insertCells(this._activeBuffer.x - pendingCols, pendingCols, this._activeBuffer.getNullCell(curAttr));
+          // test last cell - since the last cell has only room for
+          // a halfwidth char any fullwidth shifted there is lost
+          // and will be set to empty cell
+          if (bufferRow.getWidth(cols - 1) === 2) {
+            bufferRow.setCellFromCodepoint(cols - 1, NULL_CELL_CODE, NULL_CELL_WIDTH, curAttr);
+          }
+        }
+        const blockSize = buffer.allocateBigBlock();
+        bufferRow.setCellsFromCodepoints(this._activeBuffer.x - pendingCols, pendingCols, data, pendingStart, pos, curAttr, blockSize);
+        pendingStart = -1;
+        pendingCols = 0;
       }
-      const linkId = this._getCurrentLinkId();
-      if (linkId) {
-        this._oscLinkService.addLineToLink(linkId, this._activeBuffer.ybase + this._activeBuffer.y);
+      if (code < 0) {
+        break;
       }
 
       // goto next line if ch would overflow
       // NOTE: To avoid costly width checks here,
       // the terminal does not allow a cols < 2.
-      if (this._activeBuffer.x + chWidth - oldWidth > cols) {
+      if (overflowing) {
         // autowrap - DECAWM
         // automatically wraps to the beginning of the next line
         if (wraparoundMode) {
-          const oldRow = bufferRow;
-          let oldCol = this._activeBuffer.x - oldWidth;
+          const oldRow = bufferRow as BufferLine;
+          const oldCol = this._activeBuffer.x - oldWidth;
           this._activeBuffer.x = oldWidth;
           this._activeBuffer.y++;
           if (this._activeBuffer.y === this._activeBuffer.scrollBottom + 1) {
@@ -606,9 +650,7 @@ export class InputHandler extends Disposable implements IInputHandler {
               oldCol, 0, oldWidth, false);
           }
           // clear left over cells to the right
-          while (oldCol < cols) {
-            oldRow.setCellFromCodepoint(oldCol++, 0, 1, curAttr);
-          }
+          oldRow.eraseRight(oldCol);
         } else {
           this._activeBuffer.x = cols - 1;
           if (chWidth === 2) {
@@ -629,37 +671,17 @@ export class InputHandler extends Disposable implements IInputHandler {
         // it is save to step 2 cells back here
         // since an empty cell is only set by fullwidth chars
         bufferRow.addCodepointToCell(this._activeBuffer.x - offset,
-          code, chWidth);
+          code, chWidth, curAttr);
         for (let delta = chWidth - oldWidth; --delta >= 0;) {
           bufferRow.setCellFromCodepoint(this._activeBuffer.x++, 0, 0, curAttr);
         }
         continue;
       }
 
-      // insert mode: move characters to right
-      if (insertMode) {
-        // right shift cells according to the width
-        bufferRow.insertCells(this._activeBuffer.x, chWidth - oldWidth, this._activeBuffer.getNullCell(curAttr));
-        // test last cell - since the last cell has only room for
-        // a halfwidth char any fullwidth shifted there is lost
-        // and will be set to empty cell
-        if (bufferRow.getWidth(cols - 1) === 2) {
-          bufferRow.setCellFromCodepoint(cols - 1, NULL_CELL_CODE, NULL_CELL_WIDTH, curAttr);
-        }
-      }
-
-      // write current char to buffer and advance cursor
-      bufferRow.setCellFromCodepoint(this._activeBuffer.x++, code, chWidth, curAttr);
-
-      // fullwidth char - also set next cell to placeholder stub and advance cursor
-      // for graphemes bigger than fullwidth we can simply loop to zero
-      // we already made sure above, that this._activeBuffer.x + chWidth will not overflow right
-      if (chWidth > 0) {
-        while (--chWidth) {
-          // other than a regular empty cell a cell following a wide char has no width
-          bufferRow.setCellFromCodepoint(this._activeBuffer.x++, 0, 0, curAttr);
-        }
-      }
+      data[pos] = code | (chWidth << Content.WIDTH_SHIFT);
+      if (pendingStart < 0) pendingStart = pos;
+      pendingCols += chWidth;
+      this._activeBuffer.x += chWidth;
     }
 
     this._parser.precedingJoinState = precedingJoinState;
@@ -1166,24 +1188,33 @@ export class InputHandler extends Disposable implements IInputHandler {
   /**
    * Helper method to erase cells in a terminal row.
    * The cell gets replaced with the eraseChar of the terminal.
+   * Clear isWrapped if start===0;
+   * clear isWrapped of next line if end >= cols.
    * @param y The row index relative to the viewport.
    * @param start The start x index of the range to be erased.
    * @param end The end x index of the range to be erased (exclusive).
-   * @param clearWrap clear the isWrapped flag
    * @param respectProtect Whether to respect the protection attribute (DECSCA).
    */
-  private _eraseInBufferLine(y: number, start: number, end: number, clearWrap: boolean = false, respectProtect: boolean = false): void {
-    const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y);
-    if (!line) {
+  private _eraseInBufferLine(y: number, start: number, end: number, respectProtect: boolean = false): void {
+    const yAbs = y + this._activeBuffer.ybase;
+    const line = this._activeBuffer.lines.get(yAbs);
+    if (!(line instanceof BufferLine)) {
       return;
     }
-    line.replaceCells(
-      start,
-      end,
-      this._activeBuffer.getNullCell(this._eraseAttrData()),
-      respectProtect
-    );
-    if (clearWrap) {
+    if (!respectProtect && end >= this._bufferService.cols) {
+      const next = line.nextBufferLine;
+      if (next) next.asUnwrapped(line);
+      line.eraseRight(start);
+      line.logical().backgroundColor = this._curAttrData.bg & Attributes.COLOR_MASK;
+    } else {
+      line.replaceCells(
+        start,
+        end,
+        this._activeBuffer.getNullCell(this._eraseAttrData()),
+        respectProtect
+      );
+    }
+    if (start === 0) {
       this._activeBuffer.setWrapped(this._activeBuffer.ybase + y, false);
     }
   }
@@ -1194,12 +1225,8 @@ export class InputHandler extends Disposable implements IInputHandler {
    * @param y row index
    */
   private _resetBufferLine(y: number, respectProtect: boolean = false): void {
-    const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y);
-    if (line) {
-      line.fill(this._activeBuffer.getNullCell(this._eraseAttrData()), respectProtect);
-      this._bufferService.buffer.clearMarkers(this._activeBuffer.ybase + y);
-      this._activeBuffer.setWrapped(this._activeBuffer.ybase + y, false);
-    }
+    this._eraseInBufferLine(y, 0, this._bufferService.cols, respectProtect);
+    this._bufferService.buffer.clearMarkers(this._activeBuffer.ybase + y);
   }
 
   /**
@@ -1233,7 +1260,7 @@ export class InputHandler extends Disposable implements IInputHandler {
       case 0:
         j = this._activeBuffer.y;
         this._dirtyRowTracker.markDirty(j);
-        this._eraseInBufferLine(j++, this._activeBuffer.x, this._bufferService.cols, this._activeBuffer.x === 0, respectProtect);
+        this._eraseInBufferLine(j++, this._activeBuffer.x, this._bufferService.cols, respectProtect);
         for (; j < this._bufferService.rows; j++) {
           this._resetBufferLine(j, respectProtect);
         }
@@ -1243,11 +1270,7 @@ export class InputHandler extends Disposable implements IInputHandler {
         j = this._activeBuffer.y;
         this._dirtyRowTracker.markDirty(j);
         // Deleted front part of line and everything before. This line will no longer be wrapped.
-        this._eraseInBufferLine(j, 0, this._activeBuffer.x + 1, true, respectProtect);
-        if (this._activeBuffer.x + 1 >= this._bufferService.cols) {
-          // Deleted entire previous line. This next line can no longer be wrapped.
-          this._activeBuffer.setWrapped(j + 1, false);
-        }
+        this._eraseInBufferLine(j, 0, this._activeBuffer.x + 1, respectProtect);
         while (j--) {
           this._resetBufferLine(j, respectProtect);
         }
@@ -1322,13 +1345,13 @@ export class InputHandler extends Disposable implements IInputHandler {
     this._restrictCursor(this._bufferService.cols);
     switch (params.params[0]) {
       case 0:
-        this._eraseInBufferLine(this._activeBuffer.y, this._activeBuffer.x, this._bufferService.cols, this._activeBuffer.x === 0, respectProtect);
+        this._eraseInBufferLine(this._activeBuffer.y, this._activeBuffer.x, this._bufferService.cols, respectProtect);
         break;
       case 1:
-        this._eraseInBufferLine(this._activeBuffer.y, 0, this._activeBuffer.x + 1, false, respectProtect);
+        this._eraseInBufferLine(this._activeBuffer.y, 0, this._activeBuffer.x + 1, respectProtect);
         break;
       case 2:
-        this._eraseInBufferLine(this._activeBuffer.y, 0, this._bufferService.cols, true, respectProtect);
+        this._eraseInBufferLine(this._activeBuffer.y, 0, this._bufferService.cols, respectProtect);
         break;
     }
     this._dirtyRowTracker.markDirty(this._activeBuffer.y);
diff --git a/src/common/TestUtils.test.ts b/src/common/TestUtils.test.ts
index bedfa6ba1f..8961e56b6f 100644
--- a/src/common/TestUtils.test.ts
+++ b/src/common/TestUtils.test.ts
@@ -13,7 +13,10 @@ import { UnicodeV6 } from './input/UnicodeV6';
 import { IDecorationOptions, IDecoration } from '@xterm/xterm';
 import { Emitter, type IEvent } from './Event';
 import { CellData } from './buffer/CellData';
-import { DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH } from './buffer/Constants';
+import { DEFAULT_COLOR, NULL_CELL_CHAR, NULL_CELL_WIDTH } from './buffer/Constants';
+
+// Misnamed - random value for testing.
+export const DEFAULT_ATTR = (0 << 18) | (DEFAULT_COLOR << 9) | (256 << 0);
 
 export function createCellData(attr: number, char: string, width: number): CellData {
   return CellData.fromCharData([attr, char, width, char.length === 0 ? 0 : char.charCodeAt(0)]);
diff --git a/src/common/buffer/Buffer.test.ts b/src/common/buffer/Buffer.test.ts
index c2e0505e4f..c448498aaa 100644
--- a/src/common/buffer/Buffer.test.ts
+++ b/src/common/buffer/Buffer.test.ts
@@ -651,6 +651,8 @@ describe('Buffer', () => {
         // 汉语汉语汉语
         assert.equal(buffer.lines.get(0)!.translateToString(true), '汉语汉语汉语');
         assert.equal(buffer.lines.get(1)!.translateToString(true), '汉语汉语汉语');
+        assert.equal(buffer.lines.get(0)!.logical().asString(), '汉语汉语汉语汉语汉语汉语');
+        assert.equal(buffer.lines.get(1)!.startColumn, 12);
         buffer.resize(13, 10);
         assert.equal(buffer.ybase, 0);
         assert.equal(buffer.lines.length, 10);
@@ -658,11 +660,15 @@ describe('Buffer', () => {
         assert.equal(buffer.lines.get(0)!.translateToString(false), '汉语汉语汉语 ');
         assert.equal(buffer.lines.get(1)!.translateToString(true), '汉语汉语汉语');
         assert.equal(buffer.lines.get(1)!.translateToString(false), '汉语汉语汉语 ');
+        assert.equal(buffer.lines.get(0)!.logical().asString(), '汉语汉语汉语汉语汉语汉语');
+        assert.equal(buffer.lines.get(1)!.startColumn, 12);
         buffer.resize(14, 10);
         assert.equal(buffer.lines.get(0)!.translateToString(true), '汉语汉语汉语汉');
         assert.equal(buffer.lines.get(0)!.translateToString(false), '汉语汉语汉语汉');
         assert.equal(buffer.lines.get(1)!.translateToString(true), '语汉语汉语');
         assert.equal(buffer.lines.get(1)!.translateToString(false), '语汉语汉语    ');
+        assert.equal(buffer.lines.get(0)!.logical().asString(), '汉语汉语汉语汉语汉语汉语');
+        assert.equal(buffer.lines.get(1)!.startColumn, 14);
       });
       it('should correctly reflow wrapped lines that end in 0 space (via tab char)', () => {
         buffer.fillViewportRows();
@@ -712,20 +718,32 @@ describe('Buffer', () => {
         // 汉语汉语汉语
         assert.equal(buffer.lines.get(0)!.translateToString(true), '汉语汉语汉语');
         assert.equal(buffer.lines.get(1)!.translateToString(true), '汉语汉语汉语');
+        assert.equal(buffer.lines.get(0)!.logical().asString(), '汉语汉语汉语汉语汉语汉语');
+        assert.deepEqual([0, 1, 2, 3].map((i) => buffer.lines.get(i)!.startColumn),
+          [0, 12, 0, 0]);
         buffer.resize(11, 10);
         assert.equal(buffer.ybase, 0);
         assert.equal(buffer.lines.length, 10);
         assert.equal(buffer.lines.get(0)!.translateToString(true), '汉语汉语汉');
         assert.equal(buffer.lines.get(1)!.translateToString(true), '语汉语汉语');
         assert.equal(buffer.lines.get(2)!.translateToString(true), '汉语');
+        assert.equal(buffer.lines.get(0)!.logical().asString(), '汉语汉语汉语汉语汉语汉语');
+        assert.deepEqual([0, 1, 2, 3].map((i) => buffer.lines.get(i)!.startColumn),
+          [0, 10, 20, 0]);
         buffer.resize(10, 10);
         assert.equal(buffer.lines.get(0)!.translateToString(true), '汉语汉语汉');
         assert.equal(buffer.lines.get(1)!.translateToString(true), '语汉语汉语');
         assert.equal(buffer.lines.get(2)!.translateToString(true), '汉语');
+        assert.equal(buffer.lines.get(0)!.logical().asString(), '汉语汉语汉语汉语汉语汉语');
+        assert.deepEqual([0, 1, 2, 3].map((i) => buffer.lines.get(i)!.startColumn),
+          [0, 10, 20, 0]);
         buffer.resize(9, 10);
         assert.equal(buffer.lines.get(0)!.translateToString(true), '汉语汉语');
         assert.equal(buffer.lines.get(1)!.translateToString(true), '汉语汉语');
         assert.equal(buffer.lines.get(2)!.translateToString(true), '汉语汉语');
+        assert.equal(buffer.lines.get(0)!.logical().asString(), '汉语汉语汉语汉语汉语汉语');
+        assert.deepEqual([0, 1, 2, 3].map((i) => buffer.lines.get(i)!.startColumn),
+          [0, 8, 16, 0]);
         buffer.resize(8, 10);
         assert.equal(buffer.lines.get(0)!.translateToString(true), '汉语汉语');
         assert.equal(buffer.lines.get(1)!.translateToString(true), '汉语汉语');
@@ -1266,33 +1284,4 @@ describe('Buffer', () => {
       assert.equal(str3, '😁a');
     });
   });
-
-  describe('memory cleanup after shrinking', () => {
-    it('should realign memory from idle task execution', async () => {
-      buffer.fillViewportRows();
-
-      // shrink more than 2 times to trigger lazy memory cleanup
-      buffer.resize(INIT_COLS / 2 - 1, INIT_ROWS);
-
-      // sync
-      for (let i = 0; i < INIT_ROWS; i++) {
-        const line = buffer.lines.get(i)!;
-        // line memory is still at old size from initialization
-        assert.equal((line as any)._data.buffer.byteLength, INIT_COLS * 3 * 4);
-        // array.length and .length get immediately adjusted
-        assert.equal((line as any)._data.length, (INIT_COLS / 2 - 1) * 3);
-        assert.equal(line.length, INIT_COLS / 2 - 1);
-      }
-
-      // wait for a bit to give IdleTaskQueue a chance to kick in
-      // and finish memory cleaning
-      await new Promise(r => setTimeout(r, 30));
-
-      // cleanup should have realigned memory with exact bytelength
-      for (let i = 0; i < INIT_ROWS; i++) {
-        const line = buffer.lines.get(i)!;
-        assert.equal((line as any)._data.buffer.byteLength, (INIT_COLS / 2 - 1) * 3 * 4);
-      }
-    });
-  });
 });
diff --git a/src/common/buffer/Buffer.ts b/src/common/buffer/Buffer.ts
index b3ad14ee04..bb6a487a74 100644
--- a/src/common/buffer/Buffer.ts
+++ b/src/common/buffer/Buffer.ts
@@ -4,15 +4,13 @@
  */
 
 import { CircularList, IInsertEvent } from '../CircularList';
-import { Disposable, toDisposable } from '../Lifecycle';
-import { IdleTaskQueue } from '../TaskQueue';
-import { ICharset } from '../Types';
+import { Disposable } from '../Lifecycle';
 import { IAttributeData, IBuffer, IBufferLine, ICellData } from './Types';
+import { ICharset } from '../Types';
 import { ExtendedAttrs } from './AttributeData';
-import { BufferLine, DEFAULT_ATTR_DATA } from './BufferLine';
-import { getWrappedLineTrimmedLength, reflowLargerApplyNewLayout, reflowLargerCreateNewLayout, reflowLargerGetLinesToRemove, reflowSmallerGetNewLineLengths } from './BufferReflow';
+import { BufferLine, LogicalLine, DEFAULT_ATTR_DATA } from './BufferLine';
 import { CellData } from './CellData';
-import { NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_CODE, WHITESPACE_CELL_WIDTH } from './Constants';
+import { NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_CODE, WHITESPACE_CELL_WIDTH, Attributes } from './Constants';
 import { Marker } from './Marker';
 import { DEFAULT_CHARSET } from '../data/Charsets';
 import { IBufferService, ILogService, IOptionsService } from '../services/Services';
@@ -30,6 +28,7 @@ export class Buffer extends Disposable implements IBuffer {
   public lines: CircularList<IBufferLine>;
   public ydisp: number = 0;
   public ybase: number = 0;
+  /** Row number, relative to ybase. */
   public y: number = 0;
   public x: number = 0;
   public scrollBottom: number;
@@ -49,8 +48,6 @@ export class Buffer extends Disposable implements IBuffer {
   private _cols: number;
   private _rows: number;
   private _isClearing: boolean = false;
-  private _memoryCleanupQueue: InstanceType<typeof IdleTaskQueue>;
-  private _memoryCleanupPosition = 0;
 
   constructor(
     private _hasScrollback: boolean,
@@ -65,9 +62,13 @@ export class Buffer extends Disposable implements IBuffer {
     this.scrollTop = 0;
     this.scrollBottom = this._rows - 1;
     this.setupTabStops();
-    this._memoryCleanupQueue = new IdleTaskQueue(this._logService);
-    this._register(toDisposable(() => this._memoryCleanupQueue.clear()));
-    this._register(toDisposable(() => this.clearAllMarkers()));
+
+    this.lines.onTrim(amount => {
+      const first = this.lines.length && this.lines.get(0);
+      if (first instanceof BufferLine && first.isWrapped) {
+        const prev = first.getPreviousLine();
+        prev && first.asUnwrapped(prev);
+      }});
   }
 
   public getNullCell(attr?: IAttributeData): ICellData {
@@ -96,14 +97,37 @@ export class Buffer extends Disposable implements IBuffer {
     return this._whitespaceCell;
   }
 
-  public getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine {
-    return new BufferLine(this._bufferService.cols, this.getNullCell(attr), isWrapped);
+  /**
+   * Get an empty unwrapped line.
+   * @param attr Only used for the background color.
+   */
+  public getBlankLine(
+    attr: IAttributeData,
+    logicalLine: LogicalLine = new LogicalLine(this._cols)
+  ): IBufferLine {
+    logicalLine.backgroundColor = attr.bg & Attributes.COLOR_MASK;
+    return new BufferLine(this._cols, logicalLine);
   }
 
   public get hasScrollback(): boolean {
     return this._hasScrollback && this.lines.maxLength > this._rows;
   }
 
+  /**
+   * Should we allocate a big block to be used for multiple lines?
+   * This makes sense for the regular buffer, which is "mostly-append".
+   * Furthermore, a logical line can have hightly-variable length,
+   * so it makes sense to allocate from the end of a large buffer, and
+   * for sucessive lines, keep alocating from the same buffer as
+   * long it has room.
+   * For the alternate buffer, there is a bounded number of lines,
+   * and a lot more random-access and back-and-forth.
+   * @returns 0 if the answer is no, otherwise suggested block size
+   */
+  public allocateBigBlock(): number {
+    return this.hasScrollback ? 24 * this._cols : 0;
+  }
+
   public get isCursorInViewport(): boolean {
     const absoluteY = this.ybase + this.y;
     const relativeY = absoluteY - this.ydisp;
@@ -127,7 +151,14 @@ export class Buffer extends Disposable implements IBuffer {
 
   public setWrapped(absrow: number, value: boolean): void {
     const line = this.lines.get(absrow);
-    if (line) (line as BufferLine)._isWrapped = value;
+    if (!line || line.isWrapped === value)
+    {return;}
+    const prevRow = this.lines.get(absrow - 1) as BufferLine;
+    if (value) {
+      (line as BufferLine).setWrapped(prevRow);
+    } else {
+      (line as BufferLine).asUnwrapped(prevRow);
+    }
   }
 
   /**
@@ -137,8 +168,11 @@ export class Buffer extends Disposable implements IBuffer {
     if (this.lines.length === 0) {
       fillAttr ??= DEFAULT_ATTR_DATA;
       let i = this._rows;
+      const normalBuffer = this._hasScrollback;
       while (i--) {
-        this.lines.push(this.getBlankLine(fillAttr));
+        const line = this.getBlankLine(fillAttr,
+          normalBuffer ? new LogicalLine(0) : undefined);
+        this.lines.push(line);
       }
     }
   }
@@ -163,12 +197,6 @@ export class Buffer extends Disposable implements IBuffer {
    * @param newRows The new number of rows.
    */
   public resize(newCols: number, newRows: number): void {
-    // store reference to null cell with default attrs
-    const nullCell = this.getNullCell(DEFAULT_ATTR_DATA);
-
-    // count bufferlines with overly big memory to be cleaned afterwards
-    let dirtyMemoryLines = 0;
-
     // Increase max length if needed before adjustments to allow space to fill
     // as required.
     const newMaxLength = this._getCorrectBufferLength(newRows);
@@ -186,8 +214,7 @@ export class Buffer extends Disposable implements IBuffer {
       // Deal with columns increasing (reducing needs to happen after reflow)
       if (this._cols < newCols) {
         for (let i = 0; i < this.lines.length; i++) {
-          // +boolean for fast 0 or 1 conversion
-          dirtyMemoryLines += +this.lines.get(i)!.resize(newCols, nullCell);
+          this.lines.get(i)!.length = newCols;
         }
       }
 
@@ -199,7 +226,7 @@ export class Buffer extends Disposable implements IBuffer {
             if (this._optionsService.rawOptions.windowsPty.backend !== undefined || this._optionsService.rawOptions.windowsPty.buildNumber !== undefined) {
               // Just add the new missing rows on Windows as conpty reprints the screen with its
               // view of the world. Once a line enters scrollback for conpty it remains there
-              this.lines.push(new BufferLine(newCols, nullCell, false));
+              this.lines.push(new BufferLine(newCols));
             } else {
               if (this.ybase > 0 && this.lines.length <= this.ybase + this.y + addToY + 1) {
                 // There is room above the buffer and there are no empty elements below the line,
@@ -213,7 +240,7 @@ export class Buffer extends Disposable implements IBuffer {
               } else {
                 // Add a blank line if there is no buffer left at the top to scroll to, or if there
                 // are blank lines after the cursor
-                this.lines.push(new BufferLine(newCols, nullCell, false));
+                this.lines.push(new BufferLine(newCols));
               }
             }
           }
@@ -266,8 +293,7 @@ export class Buffer extends Disposable implements IBuffer {
       // Trim the end of the line off if cols shrunk
       if (this._cols > newCols) {
         for (let i = 0; i < this.lines.length; i++) {
-          // +boolean for fast 0 or 1 conversion
-          dirtyMemoryLines += +this.lines.get(i)!.resize(newCols, nullCell);
+          this.lines.get(i)!.length = newCols;
         }
       }
     }
@@ -281,35 +307,6 @@ export class Buffer extends Disposable implements IBuffer {
       const maxY = Math.max(0, this.lines.length - this.ybase - 1);
       this.y = Math.min(this.y, maxY);
     }
-
-    this._memoryCleanupQueue.clear();
-    // schedule memory cleanup only, if more than 10% of the lines are affected
-    if (dirtyMemoryLines > 0.1 * this.lines.length) {
-      this._memoryCleanupPosition = 0;
-      this._memoryCleanupQueue.enqueue(() => this._batchedMemoryCleanup());
-    }
-  }
-
-  private _batchedMemoryCleanup(): boolean {
-    let normalRun = true;
-    if (this._memoryCleanupPosition >= this.lines.length) {
-      // cleanup made it once through all lines, thus rescan in loop below to also catch shifted
-      // lines, which should finish rather quick if there are no more cleanups pending
-      this._memoryCleanupPosition = 0;
-      normalRun = false;
-    }
-    let counted = 0;
-    while (this._memoryCleanupPosition < this.lines.length) {
-      counted += this.lines.get(this._memoryCleanupPosition++)!.cleanupMemory();
-      // cleanup max 100 lines per batch
-      if (counted > 100) {
-        return true;
-      }
-    }
-    // normal runs always need another rescan afterwards
-    // if we made it here with normalRun=false, we are in a final run
-    // and can end the cleanup task for sure
-    return normalRun;
   }
 
   private get _isReflowEnabled(): boolean {
@@ -334,17 +331,106 @@ export class Buffer extends Disposable implements IBuffer {
   }
 
   private _reflowLarger(newCols: number, newRows: number): void {
-    const reflowCursorLine = this._optionsService.rawOptions.reflowCursorLine;
-    const toRemove: number[] = reflowLargerGetLinesToRemove(this.lines, this._cols, newCols, this.ybase + this.y, this.getNullCell(DEFAULT_ATTR_DATA), reflowCursorLine);
+    const toRemove: number[] = this._reflowLargerGetLinesToRemove(this._cols, newCols);
     if (toRemove.length > 0) {
-      const newLayoutResult = reflowLargerCreateNewLayout(this.lines, toRemove);
-      reflowLargerApplyNewLayout(this.lines, newLayoutResult.layout);
-      this._reflowLargerAdjustViewport(newCols, newRows, newLayoutResult.countRemoved);
+      const countRemoved = this._reflowLargerNewLayout(this.lines, toRemove);
+      this._reflowLargerAdjustViewport(newCols, newRows, countRemoved);
+    }
+  }
+
+  /**
+   * Evaluates and returns indexes to be removed after a reflow larger occurs. Lines will be removed
+   * when a wrapped line unwraps.
+   * @param oldCols The columns before resize
+   * @param newCols The columns after resize.
+   */
+  private _reflowLargerGetLinesToRemove(oldCols: number, newCols: number): number[] {
+    // Gather all BufferLines that need to be removed from the Buffer here so that they can be
+    // batched up and only committed once
+    const toRemove: number[] = [];
+    const lines = this.lines;
+    const bufferAbsoluteY = this.ybase + this.y;
+    // Whether to reflow the line containing the cursor.
+    const reflowCursorLine = this._optionsService.rawOptions.reflowCursorLine;
+
+    for (let y = 0; y < lines.length - 1; y++) {
+      // Check if this row is wrapped
+      let i = y;
+      let nextLine = lines.get(++i) as BufferLine;
+      if (!nextLine.isWrapped) {
+        continue;
+      }
+
+      // Check how many lines it's wrapped for
+      const wrappedLines: BufferLine[] = [lines.get(y) as BufferLine];
+      while (i < lines.length && nextLine.isWrapped) {
+        wrappedLines.push(nextLine);
+        nextLine = lines.get(++i) as BufferLine;
+      }
+
+      if (!reflowCursorLine) {
+        // If these lines contain the cursor don't touch them, the program will handle fixing up
+        // wrapped lines with the cursor
+        if (bufferAbsoluteY >= y && bufferAbsoluteY < i) {
+          y += wrappedLines.length - 1;
+          continue;
+        }
+      }
+      const oldWrapped = wrappedLines.length;
+      this._reflowLine(wrappedLines, newCols);
+
+      // Work backwards and remove any rows at the end that only contain null cells
+      const countToRemove = oldWrapped - wrappedLines.length;
+      if (countToRemove > 0) {
+        toRemove.push(y + oldWrapped - countToRemove); // index
+        toRemove.push(countToRemove);
+      }
+
+      y += oldWrapped - 1;
     }
+    return toRemove;
+  }
+
+  /**
+   * Creates and return the new layout for lines given an array of indexes to be removed.
+   * @param lines The buffer lines.
+   * @param toRemove The indexes to remove.
+   */
+  private _reflowLargerNewLayout(lines: CircularList<IBufferLine>, toRemove: number[]): number {
+    const newLayout: BufferLine[] = [];
+    // First iterate through the list and get the actual indexes to use for rows
+    let nextToRemoveIndex = 0;
+    let nextToRemoveStart = toRemove[nextToRemoveIndex];
+    let countRemovedSoFar = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (nextToRemoveStart === i) {
+        const countToRemove = toRemove[++nextToRemoveIndex];
+
+        // Tell markers that there was a deletion
+        lines.onDeleteEmitter.fire({
+          index: i - countRemovedSoFar,
+          amount: countToRemove
+        });
+
+        i += countToRemove - 1;
+        countRemovedSoFar += countToRemove;
+        nextToRemoveStart = toRemove[++nextToRemoveIndex];
+      } else {
+        // Record original lines so they don't get overridden when we rearrange the list
+        newLayout.push(lines.get(i) as BufferLine);
+      }
+    }
+    // Applies a new layout to the buffer. This essentially does the same as many splice calls but
+    // it's done all at once in a single iteration through the list since splice is very expensive.
+    // Now rearrange the list
+    for (let i = 0; i < newLayout.length; i++) {
+      lines.set(i, newLayout[i]);
+    }
+    lines.length = newLayout.length;
+    return countRemovedSoFar;
   }
 
   private _reflowLargerAdjustViewport(newCols: number, newRows: number, countRemoved: number): void {
-    const nullCell = this.getNullCell(DEFAULT_ATTR_DATA);
     // Adjust viewport based on number of items removed
     let viewportAdjustments = countRemoved;
     while (viewportAdjustments-- > 0) {
@@ -354,7 +440,7 @@ export class Buffer extends Disposable implements IBuffer {
         }
         if (this.lines.length < newRows) {
           // Add an extra row at the bottom of the viewport
-          this.lines.push(new BufferLine(newCols, nullCell, false));
+          this.lines.push(new BufferLine(newCols));
         }
       } else {
         if (this.ydisp === this.ybase) {
@@ -366,9 +452,41 @@ export class Buffer extends Disposable implements IBuffer {
     this.savedY = Math.max(this.savedY - countRemoved, 0);
   }
 
+  private _reflowLine(wrappedLines: BufferLine[], newCols: number): BufferLine[] {
+    const newLines: BufferLine[] = [];
+    let startCol = 0;
+    let curRow = 1;
+    let curLine = wrappedLines[0];
+    const logical = curLine.logical();
+    for (;;) {
+      const endCol = logical.charStart(startCol + newCols);
+      if (endCol >= logical.trimmedLength) {
+        curLine.nextBufferLine = undefined;
+        curLine.startColumn = startCol;
+        break;
+      }
+      let newLine;
+      if (curRow < wrappedLines.length) {
+        newLine = wrappedLines[curRow];
+        newLine.length = newCols;
+      } else {
+        newLine = new BufferLine(newCols, logical);
+        newLines.push(newLine);
+      }
+      curRow++;
+      newLine.startColumn = endCol;
+      startCol = endCol;
+      curLine.nextBufferLine = newLine;
+      curLine = newLine;
+    }
+    if (curRow < wrappedLines.length) {
+      wrappedLines.length = curRow;
+    }
+    return newLines;
+  }
+
   private _reflowSmaller(newCols: number, newRows: number): void {
     const reflowCursorLine = this._optionsService.rawOptions.reflowCursorLine;
-    const nullCell = this.getNullCell(DEFAULT_ATTR_DATA);
     // Gather all BufferLines that need to be inserted into the Buffer here so that they can be
     // batched up and only committed once
     const toInsert = [];
@@ -393,13 +511,17 @@ export class Buffer extends Disposable implements IBuffer {
         // wrapped lines with the cursor
         const absoluteY = this.ybase + this.y;
         if (absoluteY >= y && absoluteY < y + wrappedLines.length) {
+          for (let i = wrappedLines.length; --i > 0; ) {
+            wrappedLines[i].asUnwrapped(wrappedLines[i-1]);
+          }
+          for (let i = wrappedLines.length; --i >= 0; ) {
+            wrappedLines[i].eraseRight(newCols);
+          }
           continue;
         }
       }
-
-      const lastLineLength = wrappedLines[wrappedLines.length - 1].getTrimmedLength();
-      const destLineLengths = reflowSmallerGetNewLineLengths(wrappedLines, this._cols, newCols);
-      const linesToAdd = destLineLengths.length - wrappedLines.length;
+      const newLines = this._reflowLine(wrappedLines, newCols);
+      const linesToAdd = newLines.length;
       let trimmedLines: number;
       if (this.ybase === 0 && this.y !== this.lines.length - 1) {
         // If the top section of the buffer is not yet filled
@@ -408,12 +530,6 @@ export class Buffer extends Disposable implements IBuffer {
         trimmedLines = Math.max(0, this.lines.length - this.lines.maxLength + linesToAdd);
       }
 
-      // Add the new lines
-      const newLines: BufferLine[] = [];
-      for (let i = 0; i < linesToAdd; i++) {
-        const newLine = this.getBlankLine(DEFAULT_ATTR_DATA, true) as BufferLine;
-        newLines.push(newLine);
-      }
       if (newLines.length > 0) {
         toInsert.push({
           // countToInsert here gets the actual index, taking into account other inserted items.
@@ -422,46 +538,8 @@ export class Buffer extends Disposable implements IBuffer {
           newLines
         });
         countToInsert += newLines.length;
+        wrappedLines.push(...newLines);
       }
-      wrappedLines.push(...newLines);
-
-      // Copy buffer data to new locations, this needs to happen backwards to do in-place
-      let destLineIndex = destLineLengths.length - 1; // Math.floor(cellsNeeded / newCols);
-      let destCol = destLineLengths[destLineIndex]; // cellsNeeded % newCols;
-      if (destCol === 0) {
-        destLineIndex--;
-        destCol = destLineLengths[destLineIndex];
-      }
-      let srcLineIndex = wrappedLines.length - linesToAdd - 1;
-      let srcCol = lastLineLength;
-      while (srcLineIndex >= 0) {
-        const cellsToCopy = Math.min(srcCol, destCol);
-        if (wrappedLines[destLineIndex] === undefined) {
-          // Sanity check that the line exists, this has been known to fail for an unknown reason
-          // which would stop the reflow from happening if an exception would throw.
-          break;
-        }
-        wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[srcLineIndex], srcCol - cellsToCopy, destCol - cellsToCopy, cellsToCopy, true);
-        destCol -= cellsToCopy;
-        if (destCol === 0) {
-          destLineIndex--;
-          destCol = destLineLengths[destLineIndex];
-        }
-        srcCol -= cellsToCopy;
-        if (srcCol === 0) {
-          srcLineIndex--;
-          const wrappedLinesIndex = Math.max(srcLineIndex, 0);
-          srcCol = getWrappedLineTrimmedLength(wrappedLines, wrappedLinesIndex, this._cols);
-        }
-      }
-
-      // Null out the end of the line ends if a wide character wrapped to the following line
-      for (let i = 0; i < wrappedLines.length; i++) {
-        if (destLineLengths[i] < newCols) {
-          wrappedLines[i].setCell(destLineLengths[i], nullCell);
-        }
-      }
-
       // Adjust viewport as needed
       let viewportAdjustments = linesToAdd - trimmedLines;
       while (viewportAdjustments-- > 0) {
diff --git a/src/common/buffer/BufferLine.test.ts b/src/common/buffer/BufferLine.test.ts
index e14662f8e9..83079e7c16 100644
--- a/src/common/buffer/BufferLine.test.ts
+++ b/src/common/buffer/BufferLine.test.ts
@@ -2,38 +2,42 @@
  * Copyright (c) 2018 The xterm.js authors. All rights reserved.
  * @license MIT
  */
-import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE, DEFAULT_ATTR, Content, UnderlineStyle, BgFlags, Attributes, FgFlags } from './Constants';
-import { BufferLine } from './BufferLine';
+import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE, Content, UnderlineStyle, BgFlags, Attributes, FgFlags } from './Constants';
+import { BufferLine, LogicalLine } from './BufferLine';
 import { CellData } from './CellData';
 import { CharData, IBufferLine, ICellData } from './Types';
 import { assert } from 'chai';
 import { AttributeData } from './AttributeData';
-import { createCellData, NULL_CELL_DATA, extendedAttributes } from '../TestUtils.test';
+import { createCellData, NULL_CELL_DATA, DEFAULT_ATTR, extendedAttributes } from '../TestUtils.test';
 
 
 class TestBufferLine extends BufferLine {
-  constructor(cols: number, fillCellData?: ICellData, isWrapped: boolean = false) {
-    super(cols, fillCellData, isWrapped);
-  }
-
-  public get combined(): {[index: number]: string} {
-    return this._combined;
+  constructor(cols: number, fillCellData?: CellData, isWrapped: boolean = false) {
+    const lline = new LogicalLine();
+    super(cols, lline);
+    if (isWrapped) {
+      const prevLine = new BufferLine(cols, lline);
+      lline.firstBufferLine = prevLine;
+      prevLine.nextBufferLine = this;
+      this.startColumn = cols;
+      fillCellData && prevLine.fill(fillCellData);
+    } else {
+      lline.firstBufferLine = this;
+    }
+    if (fillCellData) {
+      this.fill(fillCellData);
+    }
   }
 
   public get cachedString(): string | undefined {
-    return this._cacheValid ? this._cache : undefined;
+    const logical = this.logical() as any;
+    return logical._charsIsTextValue ? logical._chars : undefined;
   }
 
   public set cachedString(value: string | undefined) {
-    this._cache = value ?? '';
-  }
-
-  public get isCachedStringTrimmed(): boolean {
-    return this._cacheTrimmed;
-  }
-
-  public set isCachedStringTrimmed(value: boolean) {
-    this._cacheTrimmed = value;
+    const logical = this.logical() as any;
+    if (value === undefined) logical._charsIsTextValue = false;
+    else { logical._chars = value; logical._charsIsTextValue = true; }
   }
 
   public toArray(): CharData[] {
@@ -194,9 +198,9 @@ describe('BufferLine', function(): void {
     assert.equal(line.length, 10);
     assert.deepEqual(line.loadCell(0, new CellData()).getAsCharData(), [0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
     assert.equal(line.isWrapped, true);
-    line = new TestBufferLine(10, createCellData(123, 'a', 456), true);
+    line = new TestBufferLine(10, createCellData(123, 'a', 1), true);
     assert.equal(line.length, 10);
-    assert.deepEqual(line.loadCell(0, new CellData()).getAsCharData(), [123, 'a', 456, 'a'.charCodeAt(0)]);
+    assert.deepEqual(line.loadCell(0, new CellData()).getAsCharData(), [123, 'a', 1, 'a'.charCodeAt(0)]);
     assert.equal(line.isWrapped, true);
   });
   it('insertCells', function(): void {
@@ -259,18 +263,6 @@ describe('BufferLine', function(): void {
       [123, 'z', 1, 'z'.charCodeAt(0)]
     ]);
   });
-  it('clone', function(): void {
-    const line = new TestBufferLine(5, undefined, true);
-    line.setCell(0, createCellData(1, 'a', 1));
-    line.setCell(1, createCellData(2, 'b', 1));
-    line.setCell(2, createCellData(3, 'c', 1));
-    line.setCell(3, createCellData(4, 'd', 1));
-    line.setCell(4, createCellData(5, 'e', 1));
-    const line2 = line.clone();
-    assert.deepEqual(TestBufferLine.prototype.toArray.apply(line2), line.toArray());
-    assert.equal(line2.length, line.length);
-    assert.equal(line2.isWrapped, line.isWrapped);
-  });
   it('copyFrom', function(): void {
     const line = new TestBufferLine(5);
     line.setCell(0, createCellData(1, 'a', 1));
@@ -278,11 +270,10 @@ describe('BufferLine', function(): void {
     line.setCell(2, createCellData(3, 'c', 1));
     line.setCell(3, createCellData(4, 'd', 1));
     line.setCell(4, createCellData(5, 'e', 1));
-    const line2 = new TestBufferLine(5, createCellData(1, 'a', 1), true);
+    const line2 = new TestBufferLine(5, createCellData(1, 'a', 1));
     line2.copyFrom(line);
     assert.deepEqual(line2.toArray(), line.toArray());
     assert.equal(line2.length, line.length);
-    assert.equal(line2.isWrapped, line.isWrapped);
   });
   it('should support combining chars', function(): void {
     // CHAR_DATA_CODE_INDEX resembles current behavior in InputHandler.print
@@ -293,8 +284,6 @@ describe('BufferLine', function(): void {
     const line2 = new TestBufferLine(5, createCellData(1, 'a', 1), true);
     line2.copyFrom(line);
     assert.deepEqual(line2.toArray(), line.toArray());
-    const line3 = line.clone();
-    assert.deepEqual(TestBufferLine.prototype.toArray.apply(line3), line.toArray());
   });
   describe('resize', function(): void {
     it('enlarge(false)', function(): void {
@@ -319,15 +308,13 @@ describe('BufferLine', function(): void {
     });
     it('should remove combining data on replaced cells after shrinking then enlarging', () => {
       const line = new TestBufferLine(10, createCellData(1, 'a', 1), false);
-      line.set(2, [ 0, '😁', 1, '😁'.charCodeAt(0) ]);
-      line.set(9, [ 0, '😁', 1, '😁'.charCodeAt(0) ]);
+      line.setCell(2, createCellData(0, '😁', 1));
+      line.setCell(9, createCellData(0, '😁', 1));
       assert.equal(line.translateToString(), 'aa😁aaaaaa😁');
-      assert.equal(Object.keys(line.combined).length, 2);
       line.resize(5, createCellData(1, 'a', 1));
       assert.equal(line.translateToString(), 'aa😁aa');
       line.resize(10, createCellData(1, 'a', 1));
       assert.equal(line.translateToString(), 'aa😁aaaaaaa');
-      assert.equal(Object.keys(line.combined).length, 1);
     });
   });
   describe('getTrimLength', function(): void {
@@ -495,7 +482,7 @@ describe('BufferLine', function(): void {
   describe('addCharToCell', () => {
     it('should set width to 1 for empty cell', () => {
       const line = new TestBufferLine(3, NULL_CELL_DATA, false);
-      line.addCodepointToCell(0, '\u0301'.charCodeAt(0), 0);
+      line.addCodepointToCell(0, '\u0301'.charCodeAt(0), 0, createCellData(DEFAULT_ATTR, '?', 1));
       const cell = line.loadCell(0, new CellData());
       // chars contains single combining char
       // width is set to 1
@@ -674,7 +661,7 @@ describe('BufferLine', function(): void {
       line.setCell(1, cell);
 
       // same eAttr, different codepoint
-      cell.content = 65;  // 'A'
+      cell.content = 65 | 1 << Content.WIDTH_SHIFT;  // 'A'
       line.setCell(2, cell);
 
       // different eAttr
@@ -786,13 +773,6 @@ describe('BufferLine', function(): void {
       // no eAttrs again
       cell.bg &= ~BgFlags.HAS_EXTENDED;
       line.setCell(4, cell);
-
-      const nLine = line.clone();
-      assert.equal(extendedAttributes(nLine, 0), extendedAttributes(line, 0));
-      assert.equal(extendedAttributes(nLine, 1), extendedAttributes(line, 1));
-      assert.equal(extendedAttributes(nLine, 2), extendedAttributes(line, 2));
-      assert.equal(extendedAttributes(nLine, 3), extendedAttributes(line, 3));
-      assert.equal(extendedAttributes(nLine, 4), extendedAttributes(line, 4));
     });
     it('copyFrom', () => {
       const initial = new TestBufferLine(5);
@@ -838,34 +818,20 @@ describe('BufferLine', function(): void {
       const trimmed = line.translateToString(true, undefined, undefined, undefined);
       assert.equal(trimmed, 'abc');
       assert.equal(line.cachedString, 'abc');
-      assert.equal(line.isCachedStringTrimmed, true);
 
       // Non-trimmed canonical request should refresh cache with the full value.
       const translated = line.translateToString(false, undefined, undefined, undefined);
       assert.equal(translated, 'abc  ');
-      assert.equal(line.cachedString, 'abc  ');
-      assert.equal(line.isCachedStringTrimmed, false);
+      assert.equal(line.cachedString, 'abc');
 
       // Once non-trimmed is cached, trimmed should be derived via trimEnd().
       assert.equal(line.translateToString(true, undefined, undefined, undefined), 'abc');
-      assert.equal(line.cachedString, 'abc  ');
-      assert.equal(line.isCachedStringTrimmed, false);
-
-      line.cachedString = 'cached-non-trimmed  ';
-      line.isCachedStringTrimmed = false;
-      assert.equal(line.translateToString(false, undefined, undefined, undefined), 'cached-non-trimmed  ');
-      assert.equal(line.translateToString(true, undefined, undefined, undefined), 'cached-non-trimmed');
-
-      line.cachedString = 'cached-trimmed';
-      line.isCachedStringTrimmed = true;
-      assert.equal(line.translateToString(true, undefined, undefined, undefined), 'cached-trimmed');
-      assert.equal(line.translateToString(false, undefined, undefined, undefined), 'abc  ');
-      assert.equal(line.cachedString, 'abc  ');
-      assert.equal(line.isCachedStringTrimmed, false);
+      assert.equal(line.cachedString, 'abc');
 
-      // Any optional translation argument should bypass cache.
-      assert.equal(line.translateToString(false, 0, 2, undefined), 'ab');
-      assert.equal(line.translateToString(true, 0, 2, undefined), 'ab');
+      line.cachedString = 'ABC';
+      assert.equal(line.translateToString(false, 0, 2, undefined), 'AB');
+      assert.equal(line.translateToString(true, 0, 2, undefined), 'AB');
+      assert.equal(line.translateToString(true, undefined, undefined, undefined), 'ABC');
     });
 
     it('should invalidate cached canonical strings on line mutations', () => {
@@ -874,13 +840,10 @@ describe('BufferLine', function(): void {
         line.fill(createCellData(1, 'a', 1));
         line.translateToString(true, undefined, undefined, undefined);
         assert.equal(line.cachedString, 'aaaaa');
-        assert.equal(line.isCachedStringTrimmed, true);
         line.translateToString(false, undefined, undefined, undefined);
         assert.equal(line.cachedString, 'aaaaa');
-        assert.equal(line.isCachedStringTrimmed, false);
         mutate(line);
         assert.equal(line.cachedString, undefined);
-        assert.equal(line.isCachedStringTrimmed, false);
       };
 
       assertCacheInvalidated(line => line.set(0, [0, 'b', 1, 'b'.charCodeAt(0)]));
diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts
index bc23da470d..95ea934842 100644
--- a/src/common/buffer/BufferLine.ts
+++ b/src/common/buffer/BufferLine.ts
@@ -3,10 +3,10 @@
  * @license MIT
  */
 
-import { CharData, IAttributeData, IBufferLine, ICellData, IExtendedAttrs } from './Types';
+import { CharData, IAttributeData, IBufferLine, ILogicalLine, ICellData, IExtendedAttrs, BufferColumn, LogicalColumn } from './Types';
 import { AttributeData } from './AttributeData';
-import { CellData } from './CellData';
-import { Attributes, BgFlags, CHAR_DATA_ATTR_INDEX, CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, Content, NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR } from './Constants';
+import { CellData, encodeRange } from './CellData';
+import { Attributes, BgFlags, Content, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR } from './Constants';
 import { stringFromCodePoint } from '../input/TextDecoder';
 
 // Buffer memory layout:
@@ -46,11 +46,457 @@ interface IExtendedAttrsExt extends IExtendedAttrs {
 export const DEFAULT_ATTR_DATA = Object.freeze(new AttributeData());
 
 // Work variables to avoid garbage collection
-let $startIndex = 0;
 const $workCell = new CellData();
 const $extended = DEFAULT_ATTR_DATA.extended.clone() as IExtendedAttrsExt;
 
 
+const EMPTY_DATA = new Uint32Array(0);
+
+/*
+ * The data "model" of a line ignoring line wrapping.
+ */
+export class LogicalLine implements ILogicalLine {
+  /**
+   * Available for this line is _data.subarray(_dstaStart, _dataStart + _dataLength)
+   * @internal
+   */
+  public _data: Uint32Array;
+
+  /**
+   * If charsIsTextValue is true: The text value of the line.
+   * If charsIsTextValue is false: Might only store combined character,
+   * and not necessarily in order.
+   */
+  protected _chars: string = '';
+
+  /**
+   * @internal
+   */
+  public _extendedAttrs: {[index: LogicalColumn]: IExtendedAttrs | undefined} = {};
+
+  public reflowNeeded: boolean = false;
+  public firstBufferLine: BufferLine | undefined;
+  public backgroundColor: number = 0;
+  /**
+   * Logical "trimmed" length of line.
+   * Must be no more than this._dataLength / 3.
+   */
+  public trimmedLength: number = 0;
+  /** If _chars is the text value of this line. */
+  public _charsIsTextValue: boolean = true;
+
+  constructor(cols: number = 0, data: Uint32Array = cols === 0 ? EMPTY_DATA : new Uint32Array(cols * Constants.CELL_INDICIES)) {
+    this._data = data;
+  }
+
+  public forEachBufferLine(callback: (line: IBufferLine) => void): void {
+    for (let line = this.firstBufferLine; line; line = line.nextBufferLine) {
+      callback(line);
+    }
+  }
+
+  /**
+   * @internal
+   */
+  public resizeData(cols: number, allocateBigBlock: number = 0): void {
+    const uint32Cells = cols * Constants.CELL_INDICIES;
+    const oldLength = this._data.length;
+    if (uint32Cells >= oldLength) {
+      // increase by at least 50%
+      const newLength = Math.max(uint32Cells + 60,
+        allocateBigBlock ? allocateBigBlock * 3 : (3 * oldLength) >> 1);
+      const data = new Uint32Array(newLength);
+      for (let i = 3 * this.trimmedLength; --i >= 0; ) {
+        data[i] = this._data[i];
+      }
+      this._data = data;
+    }
+  }
+
+  public showContents(): string {
+    let result = '[';
+    for (let i = 0; i < this.trimmedLength; i++) {
+      if (i > 0) { result += '; '; }
+      result += `#${i}:`;
+      result += this._data[i * Constants.CELL_INDICIES ].toString(16);
+      const s = this.getString(i);
+      if (s.length > 0) { result += `=${JSON.stringify(s)}`; }
+    }
+    result += ']len:'+this.trimmedLength;
+    return result;
+  }
+
+  public getWidth(index: LogicalColumn): number {
+    return index >= this.trimmedLength ? NULL_CELL_WIDTH
+      : this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] >> Content.WIDTH_SHIFT;
+  }
+
+  /**
+   * Usually same as argument, but adjust if wide or at end.
+   * @internal
+   */
+  public charStart(column: LogicalColumn): number {
+    return column > this.trimmedLength ? this.trimmedLength
+      : column > 0 && this.getWidth(column - 1) > 1 ? column - 1
+        : column;
+  }
+
+  /**
+   * Load data at `index` into `cell`.
+   */
+  public loadCell(index: LogicalColumn, cell: ICellData): ICellData {
+    if (index >= this.trimmedLength) {
+      cell.content = NULL_CELL_WIDTH << Content.WIDTH_SHIFT;
+      cell.fg = 0;
+      cell.bg = this.backgroundColor;
+      return cell;
+    }
+    const startIndex = index * Constants.CELL_INDICIES;
+    const content = this._data[startIndex + Cell.CONTENT];
+    (cell as CellData)._string = content & Content.STORED_IN_CHARS_MASK
+      ? this._chars : '';
+    cell.content = content;
+    cell.fg = this._data[startIndex + Cell.FG];
+    cell.bg = this._data[startIndex + Cell.BG];
+    if (cell.bg & BgFlags.HAS_EXTENDED) {
+      cell.extended = this._extendedAttrs[index]!;
+    } else {
+      // Do not mutate cell.extended in place: it may still reference this line's map entry from a
+      // prior loadCell into a reused CellData (e.g. $workCell during insert/dele
+      // We use $extended as blueprint and reset the internals
+      // mimicking the ctor to avoid a new allocation.
+      $extended._ext = 0;
+      $extended._urlId = 0;
+      $extended.payload = undefined;
+      cell.extended = $extended;
+    }
+
+    return cell;
+  }
+
+  public getExtended(index: LogicalColumn, validEnd: LogicalColumn = this.trimmedLength): IExtendedAttrs | undefined {
+    return index < this.trimmedLength
+      && (this._data[index * Constants.CELL_INDICIES + Cell.BG] & BgFlags.HAS_EXTENDED)
+      ? this._extendedAttrs[index]
+      : undefined;
+  }
+
+  /** Returns the string content of the cell. */
+  public getString(index: number): string {
+    if (index >= this.trimmedLength) {
+      return '';
+    }
+    const content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT];
+    if (content & Content.STORED_IN_CHARS_MASK) {
+      const start = (content & Content.START_IN_CHARS_MASK) >>> Content.START_IN_CHARS_SHIFT;
+      const length = (content & Content.LENGTH_IN_CHARS_MASK) >>> Content.LENGTH_IN_CHARS_SHIFT;
+      return this._chars.substring(start, start + length);
+    }
+    if (content & Content.CODEPOINT_MASK) {
+      return stringFromCodePoint(content & Content.CODEPOINT_MASK);
+    }
+    // return empty string for empty cells
+    return '';
+  }
+
+  /**
+   * Get codepoint of the cell.
+   * To be in line with `code` in CharData this either returns
+   * a single UTF32 codepoint or the last codepoint of a combined string.
+   */
+  public getCodePoint(index: LogicalColumn): number {
+    const content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT];
+    if (content & Content.STORED_IN_CHARS_MASK) {
+      const start = (content & Content.START_IN_CHARS_MASK) >>> Content.START_IN_CHARS_SHIFT;
+      const length = (content & Content.LENGTH_IN_CHARS_MASK) >>> Content.LENGTH_IN_CHARS_SHIFT;
+      return content & Content.IS_COMBINED_MASK
+        ? this._chars.charCodeAt(start + length - 1)
+        : (this._chars.codePointAt(start) ?? 0);
+    }
+    return content & Content.CODEPOINT_MASK;
+  }
+
+  /**
+   * A null character diplays like space, but is trimmable.
+   * Specifically it has a zero codepoint, and does not follow a wide char.
+   */
+  public isNullChar(index: LogicalColumn): boolean {
+    if (index >= this.trimmedLength) {
+      return true;
+    }
+    const content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT];
+    return ((content & Content.STORED_IN_CHARS_MASK)
+      ? (content & Content.LENGTH_IN_CHARS_MASK) === 0
+      : (content & Content.CODEPOINT_MASK) === 0)
+      && (index === 0 || this.getWidth(index - 1) < 2);
+  }
+
+  /** Get state of protected flag. */
+  public isProtected(index: number): number {
+    return this._data[index * Constants.CELL_INDICIES + Cell.BG] & BgFlags.PROTECTED;
+  }
+
+  public setCell(index: LogicalColumn, cell: ICellData): void {
+    let content = cell.content;
+    const width = cell.getWidth();
+    if (content & Content.STORED_IN_CHARS_MASK) {
+      this.setCellFromCodepoint(index, 1, width, cell);
+      if (cell instanceof CellData && cell._string === this._chars) {
+        // re-use content as-is.
+      } else if (content & Content.IS_COMBINED_MASK) {
+        const str = cell.getChars();
+        content = encodeRange(content, this._chars.length, str.length);
+        this._chars += str;
+      } else {
+        content = cell.getCode() | (width << Content.WIDTH_SHIFT);
+      }
+      this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] = content;
+      return;
+    }
+    content = content & (Content.CODEPOINT_MASK|Content.IS_COMBINED_MASK);
+    this.setCellFromCodepoint(index, content, width, cell);
+  }
+
+  /**
+   * Set cell data from input handler.
+   * Since the input handler see the incoming chars as UTF32 codepoints,
+   * it gets an optimized access method.
+   * @internal
+   */
+  public setCellFromCodepoint(index: LogicalColumn, codePoint: number, width: number, attrs: IAttributeData): void {
+    this._charsIsTextValue = false;
+    const isNull = codePoint === 0 && width === 1
+      && attrs.bg === this.backgroundColor;
+    if (isNull && index >= this.trimmedLength - 1 ) {
+      if (index === this.trimmedLength - 1) {
+        // FIXME should also truncate extendedAttrs
+        // remove any now-trailing nulls
+        while (index > 0) {
+          const j = (index - 1) * Constants.CELL_INDICIES;
+          const content = this._data[j + Cell.CONTENT];
+          if ((content & Content.HAS_CONTENT_MASK)
+            || (content & Content.WIDTH_MASK) !== 0
+            || this._data[j + Cell.BG] !== this.backgroundColor) {
+            break;
+          }
+          index--;
+        }
+        this.trimmedLength = index; // this.length - 1;
+        this.trimLength();
+      }
+      return;
+    }
+    if (index + width > this.trimmedLength && !isNull) {
+      this.resizeData(index + width);
+      let j = this.trimmedLength * Constants.CELL_INDICIES;
+      // If wide, we need to clean index+1 in addition.  We don't need
+      // to clear index (as it get overwritten) but this is simple.
+      const lastToClear = width <= 1 ? index - 1 : index + 1;
+      for (let i = this.trimmedLength; i <= lastToClear; i++) {
+        this._data[j + Cell.CONTENT] = NULL_CELL_WIDTH << Content.WIDTH_SHIFT;
+        this._data[j + Cell.FG] = 0;
+        this._data[j + Cell.BG] = this.backgroundColor;
+        j += Constants.CELL_INDICIES;
+      }
+      this.trimmedLength = index + width;
+    }
+    if (attrs.bg & BgFlags.HAS_EXTENDED) {
+      this._extendedAttrs[index] = attrs.extended;
+    }
+    const j = index * Constants.CELL_INDICIES;
+    this._data[j + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT);
+    this._data[j + Cell.FG] = attrs.fg;
+    this._data[j + Cell.BG] = attrs.bg;
+  }
+
+  public setCellsFromCodepoints(index: LogicalColumn, cols: number, codePoints: Uint32Array, start: number, end: number, attrs: IAttributeData, allocateBigBlock: number = 0): void {
+    this._charsIsTextValue = false;
+    if (index + cols >= this.trimmedLength) {
+      this.resizeData(index + cols, allocateBigBlock);
+      for (let i = this.trimmedLength; i < index; i++) {
+        const j = i * Constants.CELL_INDICIES;
+        this._data[j + Cell.CONTENT] = NULL_CELL_WIDTH << Content.WIDTH_SHIFT;
+        this._data[j + Cell.FG] = 0;
+        this._data[j + Cell.BG] = this.backgroundColor;
+      }
+      this.trimmedLength = index + cols;
+    }
+    let oldContent = -1;
+    const data = this._data;
+    const fg = attrs.fg;
+    const bg = attrs.bg;
+    const ext = (attrs.bg & BgFlags.HAS_EXTENDED) ? attrs.extended : undefined;
+    let j = index * Constants.CELL_INDICIES;
+    for (let i = start; i < end; i++) {
+      const contents = codePoints[i];
+      let width = (contents >>> Content.WIDTH_SHIFT);
+      oldContent = data[j + Cell.CONTENT];
+      data[j + Cell.CONTENT] = contents;
+      data[j + Cell.FG] = fg;
+      data[j + Cell.BG] = bg;
+      ext && (this._extendedAttrs[index] = ext);
+      j += 3; index++;
+      while (--width > 0) {
+        data[j + Cell.CONTENT] = 0;
+        data[j + Cell.FG] = fg;
+        data[j + Cell.BG] = bg;
+        ext && (this._extendedAttrs[index] = ext);
+        j += 3; index++;
+      }
+    }
+    if ((oldContent >>> Content.WIDTH_SHIFT) > 1 && index < this.trimmedLength) {
+      data[j + Cell.CONTENT] = NULL_CELL_CODE | (NULL_CELL_WIDTH << Content.WIDTH_SHIFT);
+    }
+  }
+
+  /**
+   * Add a codepoint to a cell from input handler.
+   * During input stage combining chars with a width of 0 follow and stack
+   * onto a leading char. Since we already set the attrs
+   * by the previous `setDataFromCodePoint` call, we can omit it here.
+   */
+  public addCodepointToCell(column: LogicalColumn, codePoint: number, width: number, attrs?: IAttributeData): void {
+    const dindex = column * Constants.CELL_INDICIES;
+    let content = column >= this.trimmedLength ? 0 : this._data[dindex + Cell.CONTENT];
+    const oldWidth = (content & Content.WIDTH_MASK) >> Content.WIDTH_SHIFT;
+    width = Math.max(width, 1);
+    if (width > oldWidth) {
+      content &= ~Content.WIDTH_MASK;
+      content |= width << Content.WIDTH_SHIFT;
+      if (column + width > this.trimmedLength) {
+        this.resizeData(column + width);
+        this.trimmedLength = column + width;
+      }
+    }
+    const addedStr = stringFromCodePoint(codePoint);
+    const addedLength = addedStr.length;
+    let oldCellStr;
+    const oldStrLen = this._chars.length;
+    if (content & Content.HAS_CONTENT_MASK) {
+      content |= Content.IS_COMBINED_MASK;
+      if (content & Content.STORED_IN_CHARS_MASK) {
+        const oldStart = (content & Content.START_IN_CHARS_MASK) >>> Content.START_IN_CHARS_SHIFT;
+        const oldLength = (content & Content.LENGTH_IN_CHARS_MASK) >>> Content.LENGTH_IN_CHARS_SHIFT;
+        if (oldStart + oldLength === oldStrLen) {
+          // append at end - can reuse old combined data.
+          // Preserve value of _charsIsTextValue
+          this._chars += addedStr;
+          this._data[dindex + Cell.CONTENT] = encodeRange(content, oldStart, oldLength + addedLength);
+          return;
+        }
+        oldCellStr = this._chars.substring(oldStart, oldStart + oldLength);
+      } else {
+        oldCellStr = stringFromCodePoint(content & Content.CODEPOINT_MASK);
+      }
+    } else {
+      oldCellStr = '';
+    }
+    this._charsIsTextValue = false;
+    this._chars += oldCellStr + addedStr;
+    this._data[dindex + Cell.CONTENT] = encodeRange(content, oldStrLen, oldCellStr.length + addedLength);
+    if (attrs) {
+      this._data[dindex + Cell.FG] = attrs.fg;
+      this._data[dindex + Cell.BG] = attrs.bg;
+      if (attrs.bg & BgFlags.HAS_EXTENDED) { this._extendedAttrs[column] = attrs.extended; }
+    }
+  }
+
+  /**
+   * @deprecated
+   */
+  public cleanupMemory(): number {
+    return 0;
+  }
+
+  /**
+   * @internal
+   */
+  public trimLength(): void {
+    this._charsIsTextValue = false;
+    let index = this.trimmedLength;
+    while (index > 0) {
+      index--;
+      const j = index * Constants.CELL_INDICIES;
+      const content = this._data[j + Cell.CONTENT];
+      if (content & Content.HAS_CONTENT_MASK) {
+        index++;
+        break;
+      }
+    }
+    if (index < this.trimmedLength) {
+      this.trimmedLength = index;
+      for (let line = this.firstBufferLine; line; line = line.nextBufferLine) {
+        if (line.startColumn > index) {
+          line.startColumn = index;
+        }
+      }
+      // FIXME - possible optimization - trim _data _combinedData _extendedAttrs
+    }
+  }
+
+  public copyCellsFrom(src: LogicalLine, srcCol: number, dstCol: number, length: number, applyInReverse: boolean): void {
+    this._charsIsTextValue = false;
+    let cell = applyInReverse ? length - 1 : 0;
+    const cellIncrement = applyInReverse ? -1 : 1;
+    for (let todo = length; --todo >= 0; cell += cellIncrement) {
+      src.loadCell(srcCol + cell, $workCell);
+      const dstIndex = dstCol + cell;
+      this.setCell(dstIndex, $workCell);
+    }
+  }
+
+  public asString(startCol: LogicalColumn = 0, endCol: LogicalColumn = -1): string {
+    if (!this._charsIsTextValue) {
+      const cellContents: string[] = [];
+      const llen = this.trimmedLength;
+      let nchars = 0;
+      let j = Cell.CONTENT;
+      let prevWasWide = false;
+      for (let i = 0; i < llen; i++) {
+        const cstr = this.getString(i);
+        let clen = cstr.length;
+        const content = this._data[j];
+        this._data[j] = encodeRange(content, nchars, clen);
+        const width = content >> Content.WIDTH_SHIFT;
+        if (clen > 0) {
+          cellContents.push(cstr);
+        } else if (!prevWasWide) {
+          cellContents.push(' ');
+          clen = 1;
+        }
+        j += Constants.CELL_INDICIES;
+        nchars += clen;
+        prevWasWide = width > 1;
+      }
+      const result = cellContents.join('');
+      this._charsIsTextValue = true;
+      this._chars = result;
+    }
+    if (startCol >= 0 && endCol >= 0) {
+      if (startCol >= this.trimmedLength || endCol <= startCol) { return ''; }
+      const startContent = this._data[startCol * Constants.CELL_INDICIES + Cell.CONTENT];
+      const start = (startContent & Content.START_IN_CHARS_MASK) >>> Content.START_IN_CHARS_SHIFT;
+      const lastContent = this._data[(endCol - 1) * Constants.CELL_INDICIES + Cell.CONTENT];
+      const lastStart = (lastContent & Content.START_IN_CHARS_MASK) >>> Content.START_IN_CHARS_SHIFT;
+      let lastLength = (lastContent & Content.LENGTH_IN_CHARS_MASK) >>> Content.LENGTH_IN_CHARS_SHIFT;
+      if (lastLength === 0 && (lastContent >>> Content.WIDTH_SHIFT) > 0) {
+        lastLength++; // last char is a NULL
+      }
+      return this._chars.substring(start, lastStart + lastLength);
+    }
+    return this._chars;
+  }
+
+  public offsetInString(index: LogicalColumn): number {
+    if (!this._charsIsTextValue) { this.asString(); }
+    if (index >= this.trimmedLength) {
+      return this._chars.length;
+    }
+    const content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT];
+    return (content & Content.START_IN_CHARS_MASK) >>> Content.START_IN_CHARS_SHIFT;
+  }
+}
+
 /**
  * Typed array based bufferline implementation.
  *
@@ -60,62 +506,78 @@ const $extended = DEFAULT_ATTR_DATA.extended.clone() as IExtendedAttrsExt;
  *   Used during normal input in `InputHandler` for faster buffer access.
  * - `setCell`
  *   This method takes a CellData object and stores the data in the buffer.
- *   Use `CellData.fromCharData` to create the CellData object (e.g. from JS string).
+ *   Use `CellData.fromCharData` to create the CellData object (e.g.0 f from JS string).
  *
  * To retrieve data from the buffer use either one of the primitive methods
  * (if only one particular value is needed) or `loadCell`. For `loadCell` in a loop
  * memory allocs / GC pressure can be greatly reduced by reusing the CellData object.
  */
 export class BufferLine implements IBufferLine {
-  protected _data: Uint32Array;
-  /** Sparse cache; only read when `IS_COMBINED_MASK` is set in `_data`. */
-  protected _combined: {[index: number]: string} = {};
-  /** Sparse cache; only read when `HAS_EXTENDED` is set in `_data`. */
-  protected _extendedAttrs: {[index: number]: IExtendedAttrs | undefined} = {};
-  public length: number;
+  private _logicalLine: LogicalLine;
+  public logical(): LogicalLine { return this._logicalLine; }
+  public nextBufferLine: BufferLine | undefined;
 
-  // INTERNAL - if modifying, use Buffer.setWrapped.
-  // WARNING - this field is likely to be removed or made private
-  public _isWrapped: boolean;
+  /**
+   * Number of logical columns in previous rows.
+   * Also: logical column number (column number assuming infinitely-wide
+   * terminal) corresponding to the start of this row.
+   * If R is the row number (0 for the first BufferLine for a LogicalLine),
+   * If R is 0 for the previous LogicalBufferLine, R is 1 for first
+   * then startColumn will *usually* be N*W (where W is the width of
+   * the terminal in columns) but may be slightly
+   * different when a wide character at column W-1 must wrap "early".
+   */
+  public startColumn: number = 0;
 
-  public get isWrapped(): boolean {
-    return this._isWrapped;
-  }
+  public length: number;
 
-  /** line text cache */
-  protected _cacheValid = false;
-  protected _cache: string = '';
-  protected _cacheTrimmed = false;
+  /**
+   * Last LogicalColumn of this BufferLine.
+   * @internal
+   */
+  public get validEnd(): LogicalColumn {
+    return this.nextBufferLine ? this.nextBufferLine.startColumn : this._logicalLine.trimmedLength;
+  }
 
-  constructor(
-    cols: number,
-    fillCellData?: ICellData,
-    isWrapped: boolean = false
+  constructor(cols: number,
+    logicalLine = new LogicalLine(cols)
   ) {
-    this._data = new Uint32Array(cols * Constants.CELL_INDICIES);
-    const cell = fillCellData ?? CellData.fromCharData([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
-    for (let i = 0; i < cols; ++i) {
-      this.setCell(i, cell);
-    }
+    this._logicalLine = logicalLine;
+    this.length = cols;
+    logicalLine.firstBufferLine ??= this;
+  }
+
+  public reinit(cols: number,
+    logicalLine: LogicalLine): void {
+    this._logicalLine = logicalLine;
     this.length = cols;
-    this._isWrapped = isWrapped;
+    logicalLine.firstBufferLine ??= this;
+    this.startColumn = 0;
+  }
+
+  public get isWrapped(): boolean {
+    return this._logicalLine.firstBufferLine !== this;
   }
 
   /**
    * Get cell data CharData.
    * @deprecated
    */
-  public get(index: number): CharData {
-    const content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT];
+  public get(index: BufferColumn): CharData {
+    const lline = this._logicalLine;
+    const lindex: LogicalColumn = index + this.startColumn;
+    if (lindex >= this.validEnd) {
+      return [0, '', NULL_CELL_WIDTH, 0];
+    }
+    const content = lline._data[index * Constants.CELL_INDICIES + Cell.CONTENT];
     const cp = content & Content.CODEPOINT_MASK;
+    const str = lline.getString(lindex);
     return [
-      this._data[index * Constants.CELL_INDICIES + Cell.FG],
-      (content & Content.IS_COMBINED_MASK)
-        ? this._combined[index]
-        : (cp) ? stringFromCodePoint(cp) : '',
+      lline._data[lindex * Constants.CELL_INDICIES + Cell.FG],
+      str,
       content >> Content.WIDTH_SHIFT,
       (content & Content.IS_COMBINED_MASK)
-        ? this._combined[index].charCodeAt(this._combined[index].length - 1)
+        ? str.charCodeAt(str.length - 1)
         : cp
     ];
   }
@@ -125,14 +587,7 @@ export class BufferLine implements IBufferLine {
    * @deprecated
    */
   public set(index: number, value: CharData): void {
-    this._cacheValid = false;
-    this._data[index * Constants.CELL_INDICIES + Cell.FG] = value[CHAR_DATA_ATTR_INDEX];
-    if (value[CHAR_DATA_CHAR_INDEX].length > 1) {
-      this._combined[index] = value[1];
-      this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] = index | Content.IS_COMBINED_MASK | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT);
-    } else {
-      this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] = value[CHAR_DATA_CHAR_INDEX].charCodeAt(0) | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT);
-    }
+    this.setCell(index, CellData.fromCharData(value));
   }
 
   /**
@@ -140,22 +595,29 @@ export class BufferLine implements IBufferLine {
    * use these when only one value is needed, otherwise use `loadCell`
    */
   public getWidth(index: number): number {
-    return this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] >> Content.WIDTH_SHIFT;
+    const lindex: LogicalColumn = index + this.startColumn;
+    return lindex >= this.validEnd ? NULL_CELL_WIDTH
+      : this._logicalLine.getWidth(lindex);
   }
 
   /** Test whether content has width. */
   public hasWidth(index: number): number {
-    return this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] & Content.WIDTH_MASK;
+    return this.getWidth(index);
   }
 
   /** Get FG cell component. */
   public getFg(index: number): number {
-    return this._data[index * Constants.CELL_INDICIES + Cell.FG];
+    const lline = this._logicalLine;
+    const lcolumn = index + this.startColumn;
+    return lcolumn >= this.validEnd ? 0 : lline._data[lcolumn * Constants.CELL_INDICIES + Cell.FG];
   }
 
   /** Get BG cell component. */
   public getBg(index: number): number {
-    return this._data[index * Constants.CELL_INDICIES + Cell.BG];
+    index += this.startColumn;
+    const lline = this._logicalLine;
+    return index > lline.trimmedLength ? lline.backgroundColor
+      : lline._data[index * Constants.CELL_INDICIES + Cell.BG];
   }
 
   /**
@@ -164,7 +626,12 @@ export class BufferLine implements IBufferLine {
    * from real empty cells.
    */
   public hasContent(index: number): number {
-    return this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] & Content.HAS_CONTENT_MASK;
+    index += this.startColumn;
+    if (index >= this.validEnd) {
+      return 0;
+    }
+    const lline = this._logicalLine;
+    return lline._data[index * Constants.CELL_INDICIES + Cell.CONTENT] & Content.HAS_CONTENT_MASK;
   }
 
   /**
@@ -172,35 +639,41 @@ export class BufferLine implements IBufferLine {
    * To be in line with `code` in CharData this either returns
    * a single UTF32 codepoint or the last codepoint of a combined string.
    */
-  public getCodePoint(index: number): number {
-    const content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT];
-    if (content & Content.IS_COMBINED_MASK) {
-      return this._combined[index].charCodeAt(this._combined[index].length - 1);
+  public getCodePoint(index: BufferColumn): number {
+    const lline = this._logicalLine;
+    const lcolumn: LogicalColumn = index + this.startColumn;
+    if (lcolumn >= this.validEnd) {
+      return 0;
     }
-    return content & Content.CODEPOINT_MASK;
+    return lline.getCodePoint(lcolumn);
   }
 
   /** Test whether the cell contains a combined string. */
   public isCombined(index: number): number {
-    return this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] & Content.IS_COMBINED_MASK;
+    const lline = this._logicalLine;
+    const lcolumn: LogicalColumn = index + this.startColumn;
+    if (lcolumn >= this.validEnd) {
+      return 0;
+    }
+    return lline._data[lcolumn * Constants.CELL_INDICIES + Cell.CONTENT] & Content.IS_COMBINED_MASK;
   }
 
   /** Returns the string content of the cell. */
   public getString(index: number): string {
-    const content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT];
-    if (content & Content.IS_COMBINED_MASK) {
-      return this._combined[index];
+    const lline = this._logicalLine;
+    const lcolumn: LogicalColumn = index + this.startColumn;
+    if (lcolumn >= this.validEnd) {
+      return '';
     }
-    if (content & Content.CODEPOINT_MASK) {
-      return stringFromCodePoint(content & Content.CODEPOINT_MASK);
-    }
-    // return empty string for empty cells
-    return '';
+    return lline.getString(lcolumn);
   }
 
   /** Get state of protected flag. */
   public isProtected(index: number): number {
-    return this._data[index * Constants.CELL_INDICIES + Cell.BG] & BgFlags.PROTECTED;
+    const lline = this._logicalLine;
+    const lcolumn = index + this.startColumn;
+    return index >= this.length || lcolumn >= lline.trimmedLength ? 0
+      : lline._data[lcolumn * Constants.CELL_INDICIES + Cell.BG] & BgFlags.PROTECTED;
   }
 
   /**
@@ -208,17 +681,20 @@ export class BufferLine implements IBufferLine {
    * to GC as it significantly reduced the amount of new objects/references needed.
    */
   public loadCell(index: number, cell: ICellData): ICellData {
-    $startIndex = index * Constants.CELL_INDICIES;
-    cell.content = this._data[$startIndex + Cell.CONTENT];
-    cell.fg = this._data[$startIndex + Cell.FG];
-    cell.bg = this._data[$startIndex + Cell.BG];
-    if (cell.content & Content.IS_COMBINED_MASK) {
-      cell.combinedData = this._combined[index];
-    } else {
-      cell.combinedData = '';
+    const lline = this._logicalLine;
+    const lcolumn = index + this.startColumn;
+    const lend = this.validEnd;
+    if (lcolumn >= lend) {
+      cell.content = NULL_CELL_CODE | (NULL_CELL_WIDTH << Content.WIDTH_SHIFT);
+      cell.fg = 0;
+      if (this.nextBufferLine) {
+        cell.bg = 0; // FIXME
+      } else {
+        cell.bg = lline.backgroundColor;
+      }
+      return cell;
     }
-    cell.extended = this.getExtended(index);
-    return cell;
+    return lline.loadCell(lcolumn, cell);
   }
 
   /**
@@ -236,35 +712,17 @@ export class BufferLine implements IBufferLine {
     return this.loadCell(x, new CellData());
   }
 
-  public getExtended(index: number): IExtendedAttrs {
-    $startIndex = index * Constants.CELL_INDICIES;
-    if (this._data[$startIndex + Cell.BG] & BgFlags.HAS_EXTENDED) {
-      return this._extendedAttrs[index]!;
-    }
-    // Do not mutate cell.extended in place: it may still reference this line's map entry from a
-    // prior loadCell into a reused CellData (e.g. $workCell during insert/delete).
-    // We use $extended as blueprint and reset the internals
-    // mimicking the ctor to avoid a new allocation.
-    $extended._ext = 0;
-    $extended._urlId = 0;
-    $extended.payload = undefined;
-    return $extended;
+  public getExtended(index: number): IExtendedAttrs | undefined {
+    const lline = this._logicalLine;
+    const lcolumn = index + this.startColumn;
+    return lline.getExtended(lcolumn, this.validEnd);
   }
 
   /**
    * Set data at `index` to `cell`.
    */
   public setCell(index: number, cell: ICellData): void {
-    this._cacheValid = false;
-    if (cell.content & Content.IS_COMBINED_MASK) {
-      this._combined[index] = cell.combinedData;
-    }
-    if (cell.bg & BgFlags.HAS_EXTENDED) {
-      this._extendedAttrs[index] = cell.extended;
-    }
-    this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] = cell.content;
-    this._data[index * Constants.CELL_INDICIES + Cell.FG] = cell.fg;
-    this._data[index * Constants.CELL_INDICIES + Cell.BG] = cell.bg;
+    this._logicalLine.setCell(index + this.startColumn, cell);
   }
 
   /**
@@ -273,14 +731,12 @@ export class BufferLine implements IBufferLine {
    * it gets an optimized access method.
    */
   public setCellFromCodepoint(index: number, codePoint: number, width: number, attrs: IAttributeData): void {
-    this._cacheValid = false;
-    if (attrs.bg & BgFlags.HAS_EXTENDED) {
-      this._extendedAttrs[index] = attrs.extended;
-    }
-    const $idx = index * Constants.CELL_INDICIES;
-    this._data[$idx + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT);
-    this._data[$idx + Cell.FG] = attrs.fg;
-    this._data[$idx + Cell.BG] = attrs.bg;
+    this._logicalLine.setCellFromCodepoint(index + this.startColumn,
+      codePoint, width, attrs);
+  }
+
+  public setCellsFromCodepoints(index: number, cols: number, codePoints: Uint32Array, start: number, end: number, attrs: IAttributeData, allocateBigBlock: number = 0): void {
+    this._logicalLine.setCellsFromCodepoints(index + this.startColumn, cols, codePoints, start, end, attrs, allocateBigBlock);
   }
 
   /**
@@ -289,42 +745,22 @@ export class BufferLine implements IBufferLine {
    * onto a leading char. Since we already set the attrs
    * by the previous `setDataFromCodePoint` call, we can omit it here.
    */
-  public addCodepointToCell(index: number, codePoint: number, width: number): void {
-    this._cacheValid = false;
-    let content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT];
-    if (content & Content.IS_COMBINED_MASK) {
-      // we already have a combined string, simply add
-      this._combined[index] += stringFromCodePoint(codePoint);
-    } else {
-      if (content & Content.CODEPOINT_MASK) {
-        // normal case for combining chars:
-        //  - move current leading char + new one into combined string
-        //  - set combined flag
-        this._combined[index] = stringFromCodePoint(content & Content.CODEPOINT_MASK) + stringFromCodePoint(codePoint);
-        content &= ~Content.CODEPOINT_MASK; // set codepoint in buffer to 0
-        content |= Content.IS_COMBINED_MASK;
-      } else {
-        // should not happen - we actually have no data in the cell yet
-        // simply set the data in the cell buffer with a width of 1
-        content = codePoint | (1 << Content.WIDTH_SHIFT);
-      }
-    }
-    if (width) {
-      content &= ~Content.WIDTH_MASK;
-      content |= width << Content.WIDTH_SHIFT;
-    }
-    this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] = content;
+  public addCodepointToCell(index: number, codePoint: number, width: number, attrs?: IAttributeData): void {
+    this._logicalLine.addCodepointToCell(index + this.startColumn, codePoint, width, attrs);
   }
 
   public insertCells(pos: number, n: number, fillCellData: ICellData): void {
-    this._cacheValid = false;
     pos %= this.length;
 
     // handle fullwidth at pos: reset cell one to the left if pos is second cell of a wide char
     if (pos && this.getWidth(pos - 1) === 2) {
       this.setCellFromCodepoint(pos - 1, 0, 1, fillCellData);
+      this.setCellFromCodepoint(pos, 0, 1, fillCellData);
+    }
+    // handle fullwidth at line end: reset last cell if it is first cell of a wide char
+    if (this.getWidth(this.length - n - 1) === 2) {
+      this.setCellFromCodepoint(this.length - n - 1, 0, 1, fillCellData);
     }
-
     if (n < this.length - pos) {
       for (let i = this.length - pos - n - 1; i >= 0; --i) {
         this.setCell(pos + n + i, this.loadCell(pos + i, $workCell));
@@ -337,15 +773,9 @@ export class BufferLine implements IBufferLine {
         this.setCell(i, fillCellData);
       }
     }
-
-    // handle fullwidth at line end: reset last cell if it is first cell of a wide char
-    if (this.getWidth(this.length - 1) === 2) {
-      this.setCellFromCodepoint(this.length - 1, 0, 1, fillCellData);
-    }
   }
 
   public deleteCells(pos: number, n: number, fillCellData: ICellData): void {
-    this._cacheValid = false;
     pos %= this.length;
     if (n < this.length - pos) {
       for (let i = 0; i < this.length - pos - n; ++i) {
@@ -372,7 +802,6 @@ export class BufferLine implements IBufferLine {
   }
 
   public replaceCells(start: number, end: number, fillCellData: ICellData, respectProtect: boolean = false): void {
-    this._cacheValid = false;
     // full branching on respectProtect==true, hopefully getting fast JIT for standard case
     if (respectProtect) {
       if (start && this.getWidth(start - 1) === 2 && !this.isProtected(start - 1)) {
@@ -405,74 +834,59 @@ export class BufferLine implements IBufferLine {
   }
 
   /**
-   * Resize BufferLine to `cols` filling excess cells with `fillCellData`.
+   * Resize to `cols` filling excess cells with `fillCellData`.
    * The underlying array buffer will not change if there is still enough space
    * to hold the new buffer line data.
    * Returns a boolean indicating, whether a `cleanupMemory` call would free
-   * excess memory (true after shrinking > Constants.CLEANUP_THRESHOLD).
+   * excess memory (true after shrinking > Constants.Constants.CLEANUP_THRESHOLD).
+   * Assumes single unwrapped line.
+   * @deprecated only used in tests
    */
   public resize(cols: number, fillCellData: ICellData): boolean {
-    this._cacheValid = false;
+    const logical = this._logicalLine;
+    logical._charsIsTextValue = false;
+    if (logical.firstBufferLine !== this || this.nextBufferLine) {
+      throw new Error('invalid call to resize');
+    }
     if (cols === this.length) {
-      return this._data.length * 4 * Constants.CLEANUP_THRESHOLD < this._data.buffer.byteLength;
+      return logical._data.length * Constants.CLEANUP_THRESHOLD < logical._data.buffer.byteLength;
     }
     const uint32Cells = cols * Constants.CELL_INDICIES;
     if (cols > this.length) {
-      if (this._data.buffer.byteLength >= uint32Cells * 4) {
-        // optimization: avoid alloc and data copy if buffer has enough room
-        this._data = new Uint32Array(this._data.buffer, 0, uint32Cells);
-      } else {
-        // slow path: new alloc and full data copy
-        const data = new Uint32Array(uint32Cells);
-        data.set(this._data);
-        this._data = data;
-      }
+      logical.resizeData(cols);
+      logical.trimmedLength = cols;
       for (let i = this.length; i < cols; ++i) {
         this.setCell(i, fillCellData);
       }
     } else {
       // optimization: just shrink the view on existing buffer
-      this._data = this._data.subarray(0, uint32Cells);
-      // Remove any cut off combined data
-      const keys = Object.keys(this._combined);
-      for (let i = 0; i < keys.length; i++) {
-        const key = parseInt(keys[i], 10);
-        if (key >= cols) {
-          delete this._combined[key];
-        }
-      }
+      logical._data = logical._data.subarray(0, cols * Constants.CELL_INDICIES);
       // remove any cut off extended attributes
-      const extKeys = Object.keys(this._extendedAttrs);
+      const extKeys = Object.keys(logical._extendedAttrs);
       for (let i = 0; i < extKeys.length; i++) {
         const key = parseInt(extKeys[i], 10);
         if (key >= cols) {
-          delete this._extendedAttrs[key];
+          delete logical._extendedAttrs[key];
         }
       }
     }
     this.length = cols;
-    return uint32Cells * 4 * Constants.CLEANUP_THRESHOLD < this._data.buffer.byteLength;
+    return uint32Cells * 4 * Constants.CLEANUP_THRESHOLD < logical._data.buffer.byteLength;
   }
 
   /**
    * Cleanup underlying array buffer.
    * A cleanup will be triggered if the array buffer exceeds the actual used
-   * memory by a factor of Constants.CLEANUP_THRESHOLD.
+   * memory by a factor of Constants.Constants.CLEANUP_THRESHOLD.
    * Returns 0 or 1 indicating whether a cleanup happened.
+   * @deprecated
    */
   public cleanupMemory(): number {
-    if (this._data.length * 4 * Constants.CLEANUP_THRESHOLD < this._data.buffer.byteLength) {
-      const data = new Uint32Array(this._data.length);
-      data.set(this._data);
-      this._data = data;
-      return 1;
-    }
     return 0;
   }
 
   /** fill a line with fillCharData */
   public fill(fillCellData: ICellData, respectProtect: boolean = false): void {
-    this._cacheValid = false;
     // full branching on respectProtect==true, hopefully getting fast JIT for standard case
     if (respectProtect) {
       for (let i = 0; i < this.length; ++i) {
@@ -482,87 +896,137 @@ export class BufferLine implements IBufferLine {
       }
       return;
     }
-    this._combined = {};
-    this._extendedAttrs = {};
+    const lline = this._logicalLine;
+    if (lline.firstBufferLine === this && !this.nextBufferLine) {
+      lline._extendedAttrs = {};
+    }
     for (let i = 0; i < this.length; ++i) {
       this.setCell(i, fillCellData);
     }
   }
 
-  /** alter to a full copy of line  */
-  public copyFrom(line: BufferLine, blank?: boolean): void {
-    if (this.length !== line.length) {
-      this._data = new Uint32Array(line._data);
-    } else {
-      // use high speed copy if lengths are equal
-      this._data.set(line._data);
-    }
+  /** alter to a full copy of line
+   * @deprecated only used in a few tests
+   */
+  public copyFrom(line: BufferLine): void {
+    this.copyCellsFrom(line, 0, 0, this.length, false);
     this.length = line.length;
-    if (blank) {
-      // a blank line may never hold combined or extended attrs,
-      // thus we can skip handling them
-      this._combined = {};
-      this._extendedAttrs = {};
-    } else {
-      this._copySparseMapsFrom(line);
-    }
-    this._cache = '';
-    this._cacheValid = false;
-    this._isWrapped = line._isWrapped;
   }
 
-  /** create a new clone */
-  public clone(blank?: boolean): IBufferLine {
-    const newLine = new BufferLine(0, undefined, false);
-    newLine._data = new Uint32Array(this._data);
-    newLine.length = this.length;
-    if (!blank) {
-      // a blank line may never hold combined or extended attrs,
-      // thus we can skip handling them
-      newLine._copySparseMapsFrom(this);
-    }
-    newLine._isWrapped = this._isWrapped;
-    return newLine;
+  public getTrimmedLength(): number {
+    return this.validEnd - this.startColumn;
   }
 
-  public getTrimmedLength(): number {
-    for (let i = this.length - 1; i >= 0; --i) {
-      if ((this._data[i * Constants.CELL_INDICIES + Cell.CONTENT] & Content.HAS_CONTENT_MASK)) {
-        return i + (this._data[i * Constants.CELL_INDICIES + Cell.CONTENT] >> Content.WIDTH_SHIFT);
+  public getNoBgTrimmedLength(): number {
+    if (this._logicalLine.backgroundColor) {
+      return this.length;
+    }
+    const logicalLine = this._logicalLine;
+    const startColumn = this.startColumn;
+    const data = logicalLine._data;
+    for (let i = this.validEnd; --i >= startColumn; ) {
+      const j = i * Constants.CELL_INDICIES;
+      if (!logicalLine.isNullChar(i)
+        || ((data[j + Cell.BG] & Attributes.CM_MASK))) {
+        i += data[j + Cell.CONTENT] >> Content.WIDTH_SHIFT;
+        return i - startColumn;
       }
     }
-    return 0;
+    return startColumn;
   }
 
-  public getNoBgTrimmedLength(): number {
-    for (let i = this.length - 1; i >= 0; --i) {
-      if ((this._data[i * Constants.CELL_INDICIES + Cell.CONTENT] & Content.HAS_CONTENT_MASK) || (this._data[i * Constants.CELL_INDICIES + Cell.BG] & Attributes.CM_MASK)) {
-        return i + (this._data[i * Constants.CELL_INDICIES + Cell.CONTENT] >> Content.WIDTH_SHIFT);
+  public copyCellsFrom(src: BufferLine, srcCol: number, destCol: number, length: number, applyInReverse: boolean): void {
+    this._logicalLine.copyCellsFrom(src._logicalLine, srcCol + src.startColumn,
+      destCol + this.startColumn, length, applyInReverse);
+  }
+
+  public getPreviousLine(): BufferLine | undefined {
+    for (let row = this._logicalLine.firstBufferLine; ;) {
+      if (!row) {
+        return undefined;
+      }
+      const next = row.nextBufferLine;
+      if (next === this) {
+        return row;
       }
+      row = next;
     }
-    return 0;
   }
 
-  public copyCellsFrom(src: BufferLine, srcCol: number, destCol: number, length: number, applyInReverse: boolean): void {
-    this._cacheValid = false;
-    const srcData = src._data;
-    if (applyInReverse) {
-      for (let cell = length - 1; cell >= 0; cell--) {
-        for (let i = 0; i < Constants.CELL_INDICIES; i++) {
-          this._data[(destCol + cell) * Constants.CELL_INDICIES + i] = srcData[(srcCol + cell) * Constants.CELL_INDICIES + i];
+  public eraseRight(index: BufferColumn): void {
+    this._logicalLine._charsIsTextValue = false;
+    const lineStart = this.startColumn;
+    let lineEnd = lineStart + index;
+    const lline = this._logicalLine;
+    if (lineEnd > lineStart && lline.getWidth(lineEnd - 1) === 2) {
+      lineEnd--;
+    }
+    if (this.nextBufferLine) {
+      const oldEnd = this.nextBufferLine.startColumn;
+      const count = oldEnd - lineEnd;
+      if (count > 0) {
+        let next: BufferLine | undefined = this;
+        for (;;) {
+          next = next.nextBufferLine;
+          if (!next) break;
+          next.startColumn -= count;
         }
-        this._copyCellMapsFrom(src, srcCol + cell, destCol + cell);
+        lline.copyCellsFrom(lline, oldEnd, lineEnd, lline.trimmedLength - oldEnd, false);
+        lline.trimmedLength -= count;
       }
     } else {
-      for (let cell = 0; cell < length; cell++) {
-        for (let i = 0; i < Constants.CELL_INDICIES; i++) {
-          this._data[(destCol + cell) * Constants.CELL_INDICIES + i] = srcData[(srcCol + cell) * Constants.CELL_INDICIES + i];
-        }
-        this._copyCellMapsFrom(src, srcCol + cell, destCol + cell);
+      if (lineEnd < lline.trimmedLength) {
+        lline.trimmedLength = lineEnd;
       }
     }
   }
 
+  public setWrapped(previousLine: BufferLine): BufferLine {
+    this._logicalLine._charsIsTextValue = false;
+    const column = previousLine.startColumn + previousLine.length;
+    const logicalLine = previousLine._logicalLine;
+    const oldLogical = this._logicalLine;
+    logicalLine.resizeData(column + oldLogical.trimmedLength);
+    const newData = logicalLine._data;
+    for (let i = logicalLine.trimmedLength; i < column + oldLogical.trimmedLength; i++) {
+      const i3 = i * Constants.CELL_INDICIES;
+      newData[i3 + Cell.CONTENT] = 0;
+      newData[i3 + Cell.FG] = 0;
+      newData[i3 + Cell.BG] = logicalLine.backgroundColor;
+    }
+    logicalLine.copyCellsFrom(oldLogical, 0, column, oldLogical.trimmedLength, false);
+    logicalLine.trimmedLength = column + oldLogical.trimmedLength;
+    previousLine.nextBufferLine = this;
+    for (let line: BufferLine | undefined = this; line; line = line.nextBufferLine) {
+      line.startColumn += column;
+      line._logicalLine = logicalLine;
+    }
+    return this;
+
+  }
+
+  public asUnwrapped(prevRow: BufferLine): LogicalLine {
+    this._logicalLine._charsIsTextValue = false;
+    const oldStartColumn = this.startColumn;
+    prevRow.nextBufferLine = undefined;
+    const oldLine = prevRow._logicalLine;
+    const cell = new CellData();
+    this.loadCell(oldStartColumn, cell);
+    const newLength = oldLine.trimmedLength - oldStartColumn;
+    const newLogical = new LogicalLine(newLength);
+    newLogical.copyCellsFrom(oldLine, oldStartColumn, 0, newLength, false);
+    newLogical.firstBufferLine = this;
+    for (let nextRow: BufferLine | undefined = this; nextRow; nextRow = nextRow.nextBufferLine) {
+      nextRow.startColumn -= oldStartColumn;
+      nextRow._logicalLine = newLogical;
+    }
+    oldLine.trimmedLength = oldStartColumn;
+    oldLine.trimLength();
+    // FIXME truncate/resize
+    newLogical.backgroundColor = oldLine.backgroundColor;
+    return newLogical;
+  }
+
   /**
    * Translates the buffer line to a string. Caching only applies to canonical full-line translation
    * requests (regardless of `trimRight` value).
@@ -578,65 +1042,48 @@ export class BufferLine implements IBufferLine {
    * returned string, the corresponding entries in `outColumns` will have the same column number.
    */
   public translateToString(trimRight?: boolean, startCol?: number, endCol?: number, outColumns?: number[]): string {
-    const isCanonical = (startCol === undefined || startCol === 0) && endCol === undefined && outColumns === undefined;
-    if (isCanonical && this._cacheValid) {
-      if (trimRight) {
-        return this._cacheTrimmed ? this._cache : this._cache.trimEnd();
-      }
-      if (!this._cacheTrimmed) {
-        return this._cache;
-      }
-    }
     startCol = startCol ?? 0;
     endCol = endCol ?? this.length;
     if (trimRight) {
       endCol = Math.min(endCol, this.getTrimmedLength());
     }
+    const lline = this._logicalLine;
+    const lineStart = this.startColumn;
+    startCol += lineStart;
+    endCol += lineStart;
+    let validEnd;
+    if (this.nextBufferLine) {
+      validEnd = this.nextBufferLine.startColumn;
+      while (validEnd > startCol && lline.isNullChar(validEnd - 1)) {
+        validEnd--;
+      }
+    } else {
+      validEnd = this._logicalLine.trimmedLength;
+    }
+    validEnd = Math.max(startCol, Math.min(endCol, validEnd));
+    let result = lline.asString(startCol, validEnd);
+    const paddingNeeded = trimRight ? 0 : Math.max(0, endCol - validEnd);
+    if (paddingNeeded) {
+      result += WHITESPACE_CELL_CHAR.repeat(paddingNeeded);
+    }
     if (outColumns) {
       outColumns.length = 0;
-    }
-    const cellContents: string[] = [];
-    while (startCol < endCol) {
-      const content = this._data[startCol * Constants.CELL_INDICIES + Cell.CONTENT];
-      const cp = content & Content.CODEPOINT_MASK;
-      const chars = (content & Content.IS_COMBINED_MASK) ? this._combined[startCol] : (cp) ? stringFromCodePoint(cp) : WHITESPACE_CELL_CHAR;
-      cellContents.push(chars);
-      if (outColumns) {
-        for (let i = 0; i < chars.length; ++i) {
-          outColumns.push(startCol);
+      while (startCol < validEnd) {
+        const content = lline._data[startCol * Constants.CELL_INDICIES + Cell.CONTENT];
+        let length = (content & Content.LENGTH_IN_CHARS_MASK) >>> Content.LENGTH_IN_CHARS_SHIFT;
+        const width = content >> Content.WIDTH_SHIFT;
+        if (length === 0) { length = width; }
+        for (let i = 0; i < length; ++i) {
+          outColumns.push(startCol - lineStart);
         }
+        startCol += width || 1; // always advance by at least 1
+      }
+      while (startCol < endCol) {
+        outColumns.push(startCol - lineStart);
+        startCol++;
       }
-      startCol += (content >> Content.WIDTH_SHIFT) || 1; // always advance by at least 1
-    }
-    if (outColumns) {
       outColumns.push(startCol);
     }
-    const result = cellContents.join('');
-    if (isCanonical) {
-      this._cache = result;
-      this._cacheValid = true;
-      this._cacheTrimmed = !!trimRight;
-    }
     return result;
   }
-
-  /** Copy sparse map entries for a single cell when `_data` flags require them. */
-  private _copyCellMapsFrom(src: BufferLine, srcCol: number, destCol: number): void {
-    const srcStart = srcCol * Constants.CELL_INDICIES;
-    if (src._data[srcStart + Cell.CONTENT] & Content.IS_COMBINED_MASK) {
-      this._combined[destCol] = src._combined[srcCol];
-    }
-    if (src._data[srcStart + Cell.BG] & BgFlags.HAS_EXTENDED) {
-      this._extendedAttrs[destCol] = src._extendedAttrs[srcCol];
-    }
-  }
-
-  /** Rebuild sparse maps from another line, keyed only by `_data` flags. */
-  private _copySparseMapsFrom(line: BufferLine): void {
-    this._combined = {};
-    this._extendedAttrs = {};
-    for (let i = 0; i < line.length; i++) {
-      this._copyCellMapsFrom(line, i, i);
-    }
-  }
 }
diff --git a/src/common/buffer/BufferReflow.test.ts b/src/common/buffer/BufferReflow.test.ts
index 887e36f34a..c8f355501b 100644
--- a/src/common/buffer/BufferReflow.test.ts
+++ b/src/common/buffer/BufferReflow.test.ts
@@ -7,9 +7,72 @@ import { CircularList } from '../CircularList';
 import { BufferLine } from './BufferLine';
 import { CellData } from './CellData';
 import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE } from './Constants';
-import { reflowLargerGetLinesToRemove, reflowSmallerGetNewLineLengths } from './BufferReflow';
 import { IBufferLine } from './Types';
 
+/**
+ * Gets the new line lengths for a given wrapped line. The purpose of this function it to pre-
+ * compute the wrapping points since wide characters may need to be wrapped onto the following line.
+ * This function will return an array of numbers of where each line wraps to, the resulting array
+ * will only contain the values `newCols` (when the line does not end with a wide character) and
+ * `newCols - 1` (when the line does end with a wide character), except for the last value which
+ * will contain the remaining items to fill the line.
+ *
+ * Calling this with a `newCols` value of `1` will lock up.
+ *
+ * This function is now only used for testing.
+ *
+ * @param wrappedLines The wrapped lines to evaluate.
+ * @param oldCols The columns before resize.
+ * @param newCols The columns after resize.
+ */
+function reflowSmallerGetNewLineLengths(wrappedLines: BufferLine[], oldCols: number, newCols: number): number[] {
+  const newLineLengths: number[] = [];
+  const cellsNeeded = wrappedLines.map((l, i) => getWrappedLineTrimmedLength(wrappedLines, i, oldCols)).reduce((p, c) => p + c);
+
+  // Use srcCol and srcLine to find the new wrapping point, use that to get the cellsAvailable and
+  // linesNeeded
+  let srcCol = 0;
+  let srcLine = 0;
+  let cellsAvailable = 0;
+  while (cellsAvailable < cellsNeeded) {
+    if (cellsNeeded - cellsAvailable < newCols) {
+      // Add the final line and exit the loop
+      newLineLengths.push(cellsNeeded - cellsAvailable);
+      break;
+    }
+    srcCol += newCols;
+    const oldTrimmedLength = getWrappedLineTrimmedLength(wrappedLines, srcLine, oldCols);
+    if (srcCol > oldTrimmedLength) {
+      srcCol -= oldTrimmedLength;
+      srcLine++;
+    }
+    const endsWithWide = wrappedLines[srcLine].getWidth(srcCol - 1) === 2;
+    if (endsWithWide) {
+      srcCol--;
+    }
+    const lineLength = endsWithWide ? newCols - 1 : newCols;
+    newLineLengths.push(lineLength);
+    cellsAvailable += lineLength;
+  }
+
+  return newLineLengths;
+}
+
+function getWrappedLineTrimmedLength(lines: BufferLine[], i: number, cols: number): number {
+  // If this is the last row in the wrapped line, get the actual trimmed length
+  if (i === lines.length - 1) {
+    return lines[i].getTrimmedLength();
+  }
+  // Detect whether the following line starts with a wide character and the end of the current line
+  // is null, if so then we can be pretty sure the null character should be excluded from the line
+  // length]
+  const endsInNull = !(lines[i].hasContent(cols - 1)) && lines[i].getWidth(cols - 1) === 1;
+  const followingLineStartsWithWide = lines[i + 1].getWidth(0) === 2;
+  if (endsInNull && followingLineStartsWithWide) {
+    return cols - 1;
+  }
+  return cols;
+}
 
 describe('BufferReflow', () => {
   describe('reflowSmallerGetNewLineLengths', () => {
@@ -67,7 +130,7 @@ describe('BufferReflow', () => {
       line1.set(3, [0, '语', 2, '语'.charCodeAt(0)]);
       line1.set(4, [0, '', 0, 0]);
       line1.set(5, [0, 'b', 1, 'b'.charCodeAt(0)]);
-      const line2 = new BufferLine(6, undefined, true);
+      const line2 = new BufferLine(6, undefined);
       line2.set(0, [0, 'a', 1, 'a'.charCodeAt(0)]);
       line2.set(1, [0, '汉', 2, '汉'.charCodeAt(0)]);
       line2.set(2, [0, '', 0, 0]);
@@ -94,30 +157,5 @@ describe('BufferReflow', () => {
       assert.deepEqual(reflowSmallerGetNewLineLengths([line], 4, 2), [2, 2], 'line: 汉, 语');
     });
   });
-  describe('reflowLargerGetLinesToRemove', () => {
-    const nullCell = CellData.fromCharData([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
 
-    function createWrappedLines(chars: string): CircularList<IBufferLine> {
-      const lines = new CircularList<IBufferLine>(chars.length);
-      for (let i = 0; i < chars.length; i++) {
-        const line = new BufferLine(1, undefined, i > 0);
-        line.set(0, [0, chars[i], 1, chars.charCodeAt(i)]);
-        lines.push(line);
-      }
-      return lines;
-    }
-
-    it('should skip reflow when the cursor is in a wrapped block and reflowCursorLine is false', () => {
-      const lines = createWrappedLines('abcde');
-      const skipped = reflowLargerGetLinesToRemove(lines, 1, 5, 2, nullCell, false);
-      const reflowed = reflowLargerGetLinesToRemove(lines, 1, 5, 2, nullCell, true);
-      assert.deepEqual(skipped, []);
-      assert.notDeepEqual(reflowed, []);
-    });
-
-    it('should reflow wrapped blocks when the cursor is outside the block', () => {
-      const lines = createWrappedLines('abcde');
-      assert.notDeepEqual(reflowLargerGetLinesToRemove(lines, 1, 5, 10, nullCell, false), []);
-    });
-  });
 });
diff --git a/src/common/buffer/BufferReflow.ts b/src/common/buffer/BufferReflow.ts
deleted file mode 100644
index 2c0fb74ba1..0000000000
--- a/src/common/buffer/BufferReflow.ts
+++ /dev/null
@@ -1,229 +0,0 @@
-/**
- * Copyright (c) 2019 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { BufferLine } from './BufferLine';
-import { CircularList } from '../CircularList';
-import { IBufferLine, ICellData } from './Types';
-
-export interface INewLayoutResult {
-  layout: number[];
-  countRemoved: number;
-}
-
-/**
- * Evaluates and returns indexes to be removed after a reflow larger occurs. Lines will be removed
- * when a wrapped line unwraps.
- * @param lines The buffer lines.
- * @param oldCols The columns before resize
- * @param newCols The columns after resize.
- * @param bufferAbsoluteY The absolute y position of the cursor (baseY + cursorY).
- * @param nullCell The cell data to use when filling in empty cells.
- * @param reflowCursorLine Whether to reflow the line containing the cursor.
- */
-export function reflowLargerGetLinesToRemove(lines: CircularList<IBufferLine>, oldCols: number, newCols: number, bufferAbsoluteY: number, nullCell: ICellData, reflowCursorLine: boolean): number[] {
-  // Gather all BufferLines that need to be removed from the Buffer here so that they can be
-  // batched up and only committed once
-  const toRemove: number[] = [];
-
-  for (let y = 0; y < lines.length - 1; y++) {
-    // Check if this row is wrapped
-    let i = y;
-    let nextLine = lines.get(++i) as BufferLine;
-    if (!nextLine.isWrapped) {
-      continue;
-    }
-
-    // Check how many lines it's wrapped for
-    const wrappedLines: BufferLine[] = [lines.get(y) as BufferLine];
-    while (i < lines.length && nextLine.isWrapped) {
-      wrappedLines.push(nextLine);
-      nextLine = lines.get(++i) as BufferLine;
-    }
-
-    if (!reflowCursorLine) {
-      // If these lines contain the cursor don't touch them, the program will handle fixing up
-      // wrapped lines with the cursor
-      if (bufferAbsoluteY >= y && bufferAbsoluteY < i) {
-        y += wrappedLines.length - 1;
-        continue;
-      }
-    }
-
-    // Copy buffer data to new locations
-    let destLineIndex = 0;
-    let destCol = getWrappedLineTrimmedLength(wrappedLines, destLineIndex, oldCols);
-    let srcLineIndex = 1;
-    let srcCol = 0;
-    while (srcLineIndex < wrappedLines.length) {
-      const srcTrimmedTineLength = getWrappedLineTrimmedLength(wrappedLines, srcLineIndex, oldCols);
-      const srcRemainingCells = srcTrimmedTineLength - srcCol;
-      const destRemainingCells = newCols - destCol;
-      const cellsToCopy = Math.min(srcRemainingCells, destRemainingCells);
-
-      wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[srcLineIndex], srcCol, destCol, cellsToCopy, false);
-
-      destCol += cellsToCopy;
-      if (destCol === newCols) {
-        destLineIndex++;
-        destCol = 0;
-      }
-      srcCol += cellsToCopy;
-      if (srcCol === srcTrimmedTineLength) {
-        srcLineIndex++;
-        srcCol = 0;
-      }
-
-      // Make sure the last cell isn't wide, if it is copy it to the current dest
-      if (destCol === 0 && destLineIndex !== 0) {
-        if (wrappedLines[destLineIndex - 1].getWidth(newCols - 1) === 2) {
-          wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[destLineIndex - 1], newCols - 1, destCol++, 1, false);
-          // Null out the end of the last row
-          wrappedLines[destLineIndex - 1].setCell(newCols - 1, nullCell);
-        }
-      }
-    }
-
-    // Clear out remaining cells or fragments could remain;
-    wrappedLines[destLineIndex].replaceCells(destCol, newCols, nullCell);
-
-    // Work backwards and remove any rows at the end that only contain null cells
-    let countToRemove = 0;
-    for (let i = wrappedLines.length - 1; i > 0; i--) {
-      if (i > destLineIndex || wrappedLines[i].getTrimmedLength() === 0) {
-        countToRemove++;
-      } else {
-        break;
-      }
-    }
-
-    if (countToRemove > 0) {
-      toRemove.push(y + wrappedLines.length - countToRemove); // index
-      toRemove.push(countToRemove);
-    }
-
-    y += wrappedLines.length - 1;
-  }
-  return toRemove;
-}
-
-/**
- * Creates and return the new layout for lines given an array of indexes to be removed.
- * @param lines The buffer lines.
- * @param toRemove The indexes to remove.
- */
-export function reflowLargerCreateNewLayout(lines: CircularList<IBufferLine>, toRemove: number[]): INewLayoutResult {
-  const layout: number[] = [];
-  // First iterate through the list and get the actual indexes to use for rows
-  let nextToRemoveIndex = 0;
-  let nextToRemoveStart = toRemove[nextToRemoveIndex];
-  let countRemovedSoFar = 0;
-  for (let i = 0; i < lines.length; i++) {
-    if (nextToRemoveStart === i) {
-      const countToRemove = toRemove[++nextToRemoveIndex];
-
-      // Tell markers that there was a deletion
-      lines.onDeleteEmitter.fire({
-        index: i - countRemovedSoFar,
-        amount: countToRemove
-      });
-
-      i += countToRemove - 1;
-      countRemovedSoFar += countToRemove;
-      nextToRemoveStart = toRemove[++nextToRemoveIndex];
-    } else {
-      layout.push(i);
-    }
-  }
-  return {
-    layout,
-    countRemoved: countRemovedSoFar
-  };
-}
-
-/**
- * Applies a new layout to the buffer. This essentially does the same as many splice calls but it's
- * done all at once in a single iteration through the list since splice is very expensive.
- * @param lines The buffer lines.
- * @param newLayout The new layout to apply.
- */
-export function reflowLargerApplyNewLayout(lines: CircularList<IBufferLine>, newLayout: number[]): void {
-  // Record original lines so they don't get overridden when we rearrange the list
-  const newLayoutLines: BufferLine[] = [];
-  for (let i = 0; i < newLayout.length; i++) {
-    newLayoutLines.push(lines.get(newLayout[i]) as BufferLine);
-  }
-
-  // Rearrange the list
-  for (let i = 0; i < newLayoutLines.length; i++) {
-    lines.set(i, newLayoutLines[i]);
-  }
-  lines.length = newLayout.length;
-}
-
-/**
- * Gets the new line lengths for a given wrapped line. The purpose of this function it to pre-
- * compute the wrapping points since wide characters may need to be wrapped onto the following line.
- * This function will return an array of numbers of where each line wraps to, the resulting array
- * will only contain the values `newCols` (when the line does not end with a wide character) and
- * `newCols - 1` (when the line does end with a wide character), except for the last value which
- * will contain the remaining items to fill the line.
- *
- * Calling this with a `newCols` value of `1` will lock up.
- *
- * @param wrappedLines The wrapped lines to evaluate.
- * @param oldCols The columns before resize.
- * @param newCols The columns after resize.
- */
-export function reflowSmallerGetNewLineLengths(wrappedLines: BufferLine[], oldCols: number, newCols: number): number[] {
-  const newLineLengths: number[] = [];
-  let cellsNeeded = 0;
-  for (let i = 0; i < wrappedLines.length; i++) {
-    cellsNeeded += getWrappedLineTrimmedLength(wrappedLines, i, oldCols);
-  }
-
-  // Use srcCol and srcLine to find the new wrapping point, use that to get the cellsAvailable and
-  // linesNeeded
-  let srcCol = 0;
-  let srcLine = 0;
-  let cellsAvailable = 0;
-  while (cellsAvailable < cellsNeeded) {
-    if (cellsNeeded - cellsAvailable < newCols) {
-      // Add the final line and exit the loop
-      newLineLengths.push(cellsNeeded - cellsAvailable);
-      break;
-    }
-    srcCol += newCols;
-    const oldTrimmedLength = getWrappedLineTrimmedLength(wrappedLines, srcLine, oldCols);
-    if (srcCol > oldTrimmedLength) {
-      srcCol -= oldTrimmedLength;
-      srcLine++;
-    }
-    const endsWithWide = wrappedLines[srcLine].getWidth(srcCol - 1) === 2;
-    if (endsWithWide) {
-      srcCol--;
-    }
-    const lineLength = endsWithWide ? newCols - 1 : newCols;
-    newLineLengths.push(lineLength);
-    cellsAvailable += lineLength;
-  }
-
-  return newLineLengths;
-}
-
-export function getWrappedLineTrimmedLength(lines: BufferLine[], i: number, cols: number): number {
-  // If this is the last row in the wrapped line, get the actual trimmed length
-  if (i === lines.length - 1) {
-    return lines[i].getTrimmedLength();
-  }
-  // Detect whether the following line starts with a wide character and the end of the current line
-  // is null, if so then we can be pretty sure the null character should be excluded from the line
-  // length]
-  const endsInNull = !(lines[i].hasContent(cols - 1)) && lines[i].getWidth(cols - 1) === 1;
-  const followingLineStartsWithWide = lines[i + 1].getWidth(0) === 2;
-  if (endsInNull && followingLineStartsWithWide) {
-    return cols - 1;
-  }
-  return cols;
-}
diff --git a/src/common/buffer/CellData.ts b/src/common/buffer/CellData.ts
index 3c738f77ff..cbe8d6df2f 100644
--- a/src/common/buffer/CellData.ts
+++ b/src/common/buffer/CellData.ts
@@ -24,7 +24,14 @@ export class CellData extends AttributeData implements ICellData {
   public fg = 0;
   public bg = 0;
   public extended: IExtendedAttrs = new ExtendedAttrs();
-  public combinedData = '';
+  /**
+   * Base string value of cell.
+   * Only valid if STORED_IN_CHARS_MASK is set in content field.
+   */
+  public _string: string  = '';
+  public get combinedData(): string {
+    return this.isCombined() ? this.getChars() : '';
+  }
   /** Whether cell contains a combined string. */
   public isCombined(): number {
     return this.content & Content.IS_COMBINED_MASK;
@@ -35,14 +42,22 @@ export class CellData extends AttributeData implements ICellData {
   }
   /** JS string of the content. */
   public getChars(): string {
-    if (this.content & Content.IS_COMBINED_MASK) {
-      return this.combinedData;
-    }
-    if (this.content & Content.CODEPOINT_MASK) {
+    const content = this.content;
+    if (content & Content.STORED_IN_CHARS_MASK) {
+      const start = (content & Content.START_IN_CHARS_MASK) >>> Content.START_IN_CHARS_SHIFT;
+      const length = (content & Content.LENGTH_IN_CHARS_MASK) >>> Content.LENGTH_IN_CHARS_SHIFT;
+      const str = this._string;
+      return start === 0 && length === str.length ? str
+        : str.substring(start, start + length);
+    }
+    const codePoint = this.content & Content.CODEPOINT_MASK;
+    if (codePoint) {
+      // FIXME maybe cache value in _string field?
       return stringFromCodePoint(this.content & Content.CODEPOINT_MASK);
     }
     return '';
   }
+
   /**
    * Codepoint of cell
    * Note this returns the UTF32 codepoint of single chars,
@@ -50,25 +65,35 @@ export class CellData extends AttributeData implements ICellData {
    * of the last char in string to be in line with code in CharData.
    */
   public getCode(): number {
-    return (this.isCombined())
-      ? this.combinedData.charCodeAt(this.combinedData.length - 1)
-      : this.content & Content.CODEPOINT_MASK;
+    const content = this.content;
+    if (content & Content.STORED_IN_CHARS_MASK) {
+      const start = (content & Content.START_IN_CHARS_MASK) >>> Content.START_IN_CHARS_SHIFT;
+      const length = (content & Content.LENGTH_IN_CHARS_MASK) >>> Content.LENGTH_IN_CHARS_SHIFT;
+      const code = length ? this._string.charCodeAt(start + length - 1) : 0;
+      return !code ? 0
+        : code < 0xDC000 || code > 0xDFFF || length < 2 ? code
+          : this._string.codePointAt(start + length - 2) || code;
+      return code;
+    }
+    return content & Content.CODEPOINT_MASK;
   }
+
   /** Set data from CharData */
   public setFromCharData(value: CharData): void {
     this.fg = value[CHAR_DATA_ATTR_INDEX];
     this.bg = 0;
     let combined = false;
+    const str = value[CHAR_DATA_CHAR_INDEX];
     // surrogates and combined strings need special treatment
-    if (value[CHAR_DATA_CHAR_INDEX].length > 2) {
+    if (str.length > 2) {
       combined = true;
     }
-    else if (value[CHAR_DATA_CHAR_INDEX].length === 2) {
-      const code = value[CHAR_DATA_CHAR_INDEX].charCodeAt(0);
+    else if (str.length === 2) {
+      const code = str.charCodeAt(0);
       // if the 2-char string is a surrogate create single codepoint
       // everything else is combined
       if (0xD800 <= code && code <= 0xDBFF) {
-        const second = value[CHAR_DATA_CHAR_INDEX].charCodeAt(1);
+        const second = str.charCodeAt(1);
         if (0xDC00 <= second && second <= 0xDFFF) {
           this.content = ((code - 0xD800) * 0x400 + second - 0xDC00 + 0x10000) | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT);
         }
@@ -81,14 +106,19 @@ export class CellData extends AttributeData implements ICellData {
       }
     }
     else {
-      this.content = value[CHAR_DATA_CHAR_INDEX].charCodeAt(0) | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT);
+      this.content = str.charCodeAt(0) | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT);
     }
     if (combined) {
-      this.combinedData = value[CHAR_DATA_CHAR_INDEX];
-      this.content = Content.IS_COMBINED_MASK | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT);
+      this._string = str;
+      this.content = encodeRange(Content.IS_COMBINED_MASK | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT),
+        0, str.length);
+    } else {
+      this._string = '';
     }
   }
-  /** Get data as CharData. */
+  /** Get data as CharData.
+   * @deprecated
+   */
   public getAsCharData(): CharData {
     return [this.fg, this.getChars(), this.getWidth(), this.getCode()];
   }
@@ -149,3 +179,9 @@ export class CellData extends AttributeData implements ICellData {
   }
 
 }
+
+export function encodeRange(content: number, start: number, length: number): number {
+  content &= ~(Content.START_IN_CHARS_MASK | Content.LENGTH_IN_CHARS_MASK);
+  content |= (start << Content.START_IN_CHARS_SHIFT) | (length << Content.LENGTH_IN_CHARS_SHIFT) | Content.STORED_IN_CHARS_MASK;
+  return content;
+}
diff --git a/src/common/buffer/Constants.ts b/src/common/buffer/Constants.ts
index c02dba50d9..87f03eabe1 100644
--- a/src/common/buffer/Constants.ts
+++ b/src/common/buffer/Constants.ts
@@ -4,7 +4,6 @@
  */
 
 export const DEFAULT_COLOR = 0;
-export const DEFAULT_ATTR = (0 << 18) | (DEFAULT_COLOR << 9) | (256 << 0);
 export const DEFAULT_EXT = 0;
 
 export const CHAR_DATA_ATTR_INDEX = 0;
@@ -32,6 +31,15 @@ export const WHITESPACE_CELL_CODE = 32;
 
 /**
  * Bitmasks for accessing data in `content`.
+ * Text contrent is one of:
+ * (a) Directly stored in the content word as a 21-bit Unicode code point.
+ * In this case CODEPOINT_MASK contains the codepoint.
+ * STORED_IN_CHARS_MASK and IS_COMBINED_MASK are always 0 in this case.
+ * (b) A substring of the LogicalLine's _chars property.
+ * In this case STORED_IN_CHARS_MASK is non-zero.
+ * IS_COMBINED_MASK may be zero or non-zero.
+ * The first char is in START_IN_CHARS_MASK and the length is in
+ * LENGTH_IN_CHARS_MASK.
  */
 export const enum Content {
   /**
@@ -54,10 +62,11 @@ export const enum Content {
   /**
    * bit 1..22    mask to check whether a cell contains any string data
    *              we need to check for codepoint and isCombined bits to see
-   *              whether a cell contains anything
+   *              whether a cell contains anything.
+   *              We also check LENGTH_IN_CHARS_MASK in case STORED_IN_CHARS_MASK.
    *              read:   `isEmpty = !(content & Content.HAS_CONTENT_MASK)`
    */
-  HAS_CONTENT_MASK = 0x3FFFFF,
+  HAS_CONTENT_MASK = 0x0F3FFFFF,
 
   /**
    * bit 23..24   wcwidth value of cell, takes 2 bits (ranges from 0..2)
@@ -69,11 +78,24 @@ export const enum Content {
    *                      shortcut if precondition `0 <= width <= 3` is met:
    *                      `content |= width << Content.WIDTH_SHIFT;`
    */
-  WIDTH_MASK = 0xC00000,   // 3 << 22
-  WIDTH_SHIFT = 22
+  WIDTH_MASK = 0xF0000000,   // 3 << WIDTH_SHIFT
+  WIDTH_SHIFT = 28,
+  START_IN_CHARS_MASK = 0x1FFFFF,
+  START_IN_CHARS_SHIFT = 0,
+  LENGTH_IN_CHARS_MASK = 0x0F000000,
+  LENGTH_IN_CHARS_SHIFT = 24,
+  STORED_IN_CHARS_MASK = 0x400000 // 1 << 24
+  // FIXME non-optimal values for some shifts and masks.
+  // The width field must be high-order, unless WIDTH_MASK is used more
+  // The width first field be high-order bits unless we replace >> by >>>.
 }
 
 export const enum Attributes {
+  /**
+   * Color is encoded using 26 bits. If those, the high-order 2 bits is the
+   * color mode, which specifies how to interpret the remaining 24 bits.
+   */
+  COLOR_MASK = 0x3FFFFFF, /* CM_MASK | RGB_MASK */
   /**
    * bit 1..8     blue in RGB, color in P256 and P16
    */
diff --git a/src/common/buffer/Types.ts b/src/common/buffer/Types.ts
index 66f623bb55..648ac3b048 100644
--- a/src/common/buffer/Types.ts
+++ b/src/common/buffer/Types.ts
@@ -14,6 +14,20 @@ export type BufferIndex = [number, number];
 
 export type CharData = [attr: number, char: string, width: number, code: number];
 
+/*
+ * Column count within current visible BufferLine(row).
+ * The left-most column is column 0.
+ */
+export type BufferColumn = number;
+
+/*
+ * Column count within current LogicalLine.
+ * If the display is 80 columns wide, then LineColumn of the left-most
+ * character of the first wrapped line would normally be 80.
+ * (It might be 79 if the character at column 79 is double-width.)
+ */
+export type LogicalColumn = number;
+
 export interface IExtendedAttrs {
   ext: number;
   underlineStyle: UnderlineStyle;
@@ -114,26 +128,37 @@ export interface ICellData extends IAttributeData {
   getAsCharData(): CharData;
 }
 
+export interface ILogicalLine {
+  forEachBufferLine(callback: (line: IBufferLine) => void): void;
+  asString(startCol?: LogicalColumn, endCol?: LogicalColumn): string;
+  offsetInString(index: LogicalColumn): number;
+}
+
 /**
  * Interface for a line in the terminal buffer.
  */
 export interface IBufferLine {
   length: number;
-  readonly isWrapped: boolean;
+  startColumn: number;
+  logical(): ILogicalLine;
+  get isWrapped(): boolean;
   get(index: number): CharData;
   set(index: number, value: CharData): void;
   loadCell(index: number, cell: ICellData): ICellData;
   setCell(index: number, cell: ICellData): void;
   setCellFromCodepoint(index: number, codePoint: number, width: number, attrs: IAttributeData): void;
-  addCodepointToCell(index: number, codePoint: number, width: number): void;
+  setCellsFromCodepoints(index: number, cols: number, codePoints: Uint32Array, start: number, end: number, attrs: IAttributeData): void;
+  addCodepointToCell(index: number, codePoint: number, width: number, attrs?: IAttributeData): void;
   insertCells(pos: number, n: number, ch: ICellData): void;
   deleteCells(pos: number, n: number, fill: ICellData): void;
   replaceCells(start: number, end: number, fill: ICellData, respectProtect?: boolean): void;
   resize(cols: number, fill: ICellData): boolean;
+  /**
+   * @deprecated
+   */
   cleanupMemory(): number;
   fill(fillCellData: ICellData, respectProtect?: boolean): void;
-  copyFrom(line: IBufferLine, blank?: boolean): void;
-  clone(blank?: boolean): IBufferLine;
+  copyFrom(line: IBufferLine): void;
   getTrimmedLength(): number;
   getNoBgTrimmedLength(): number;
   translateToString(trimRight?: boolean, startCol?: number, endCol?: number, outColumns?: number[]): string;
@@ -147,7 +172,7 @@ export interface IBufferLine {
   getCodePoint(index: number): number;
   isCombined(index: number): number;
   getString(index: number): string;
-  getExtended(index: number): IExtendedAttrs;
+  getExtended(index: number): IExtendedAttrs | undefined;
 }
 
 export interface IMarker extends IDisposable {
@@ -159,10 +184,33 @@ export interface IMarker extends IDisposable {
 
 export interface IBuffer {
   readonly lines: ICircularList<IBufferLine>;
+  /**
+   * Number of rows above top visible row.
+   * Similar to scrollTop (i.e. affected by scrollbar), but in rows.
+   */
   ydisp: number;
+  /** Number of rows in the scrollback buffer, above the home row. */
   ybase: number;
+
+  /**
+   * Row number relative to the "home" row, zero-origin.
+   * This is the row number changed/reported by cursor escape sequences,
+   * except that y is 0-origin: y=0 when we're at the home row.
+   * Currently assumed to be >= 0, but future may allow negative - i.e.
+   * in scroll-back area, as long as ybase+y >= 0.
+   */
   y: number;
+
+  /**
+   * Column number, zero-origin.
+   * Valid range is 0 through C (inclusive), if C is terminal width in columns.
+   * The first (left-most) column is 0.
+   * The right-most column is either C-1 (before the right-most column, and
+   * ready to write in it), or C (after the right-most column, having written
+   * to it, and ready to wrap). DSR 6 returns C (1-origin) in either case,
+   */
   x: number;
+
   tabs: any;
   scrollBottom: number;
   scrollTop: number;
@@ -181,7 +229,7 @@ export interface IBuffer {
   getWrappedRangeForLine(y: number): { first: number, last: number };
   nextStop(x?: number): number;
   prevStop(x?: number): number;
-  getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine;
+  getBlankLine(attr: IAttributeData, logicalLine?: ILogicalLine): IBufferLine;
   getNullCell(attr?: IAttributeData): ICellData;
   getWhitespaceCell(attr?: IAttributeData): ICellData;
   addMarker(y: number): IMarker;
diff --git a/src/common/services/BufferService.ts b/src/common/services/BufferService.ts
index 3bd1f7e42d..5fa91dcb40 100644
--- a/src/common/services/BufferService.ts
+++ b/src/common/services/BufferService.ts
@@ -5,8 +5,10 @@
 
 import { Disposable } from '../Lifecycle';
 import { IAttributeData, IBuffer, IBufferLine, IBufferSet } from '../buffer/Types';
-import { BufferLine } from '../buffer/BufferLine';
+import { BufferLine, LogicalLine } from '../buffer/BufferLine';
 import { BufferSet } from '../buffer/BufferSet';
+import { Buffer } from '../buffer/Buffer';
+import { Attributes } from '../buffer/Constants';
 import { IBufferService, ILogService, IOptionsService, type IBufferResizeEvent } from './Services';
 import { Emitter } from '../Event';
 
@@ -67,33 +69,57 @@ export class BufferService extends Disposable implements IBufferService {
    * @param isWrapped Whether the new line is wrapped from the previous line.
    */
   public scroll(eraseAttr: IAttributeData, isWrapped: boolean = false): void {
-    const buffer = this.buffer;
-
-    let newLine: IBufferLine | undefined;
-    newLine = this._cachedBlankLine;
-    if (!newLine || newLine.length !== this.cols || newLine.getFg(0) !== eraseAttr.fg || newLine.getBg(0) !== eraseAttr.bg) {
-      newLine = buffer.getBlankLine(eraseAttr, isWrapped);
-      this._cachedBlankLine = newLine;
-    } else {
-      (newLine as BufferLine)._isWrapped = isWrapped;
-    }
-
+    const buffer = this.buffer as Buffer;
     const topRow = buffer.ybase + buffer.scrollTop;
     const bottomRow = buffer.ybase + buffer.scrollBottom;
+    const atBottom = bottomRow === buffer.lines.length - 1;
+    if (!atBottom) {
+      buffer.setWrapped(bottomRow + 1, false);
+    }
+    const oldLine = buffer.lines.get(bottomRow) as BufferLine;
+    // Determine whether the buffer is going to be trimmed after insertion.
+    const willBufferBeTrimmed = buffer.lines.isFull;
+
+    let lline: LogicalLine = oldLine.logical();
+    const recycledLine = buffer.scrollTop === 0 && atBottom && willBufferBeTrimmed
+      && buffer.lines.recycle() as BufferLine;
+    if (isWrapped) {
+    } else if (buffer.allocateBigBlock() > 0) {
+      // In this case we try to use a large block for many lines.
+      // Grab the rest of the block
+      const data = lline._data;
+      const dbuffer = data.buffer;
+      const newStart = data.byteOffset + 3 * 4 * lline.trimmedLength;
+      const newLength = data.length - 3 * lline.trimmedLength;
+      lline._data = new Uint32Array(dbuffer, data.byteOffset, 3 * lline.trimmedLength);
+      const nbuffer = new Uint32Array(dbuffer, newStart, newLength);
+      // Perhaps should also re-use recycledLine.logical().
+      // However, that seems to be slightly slower - unclear why.
+      lline = new LogicalLine(0, nbuffer);
+    } else {
+      lline = new LogicalLine(this.cols);
+    }
+    let newLine;
+    if (recycledLine) {
+      recycledLine.reinit(this.cols, lline);
+      newLine = recycledLine;
+    } else {
+      newLine = buffer.getBlankLine(eraseAttr, lline) as BufferLine;
+    }
+    if (isWrapped && oldLine) {
+      oldLine.nextBufferLine = newLine;
+      newLine.startColumn = lline.trimmedLength;
+    }
+    lline.backgroundColor = eraseAttr.bg & Attributes.COLOR_MASK;
 
     if (buffer.scrollTop === 0) {
-      // Determine whether the buffer is going to be trimmed after insertion.
-      const willBufferBeTrimmed = buffer.lines.isFull;
-
       // Insert the line using the fastest method
-      if (bottomRow === buffer.lines.length - 1) {
-        if (willBufferBeTrimmed) {
-          buffer.lines.recycle().copyFrom(newLine, true);
-        } else {
-          buffer.lines.push(newLine.clone(true));
+      if (atBottom) {
+        if (!willBufferBeTrimmed) {
+          buffer.lines.push(newLine);
         }
       } else {
-        buffer.lines.splice(bottomRow + 1, 0, newLine.clone(true));
+        buffer.lines.splice(bottomRow + 1, 0, newLine);
       }
 
       // Only adjust ybase and ydisp when the buffer is not trimmed
@@ -115,7 +141,7 @@ export class BufferService extends Disposable implements IBufferService {
       // scrollback, instead we can just shift them in-place.
       const scrollRegionHeight = bottomRow - topRow + 1 /* as it's zero-based */;
       buffer.lines.shiftElements(topRow + 1, scrollRegionHeight - 1, -1);
-      buffer.lines.set(bottomRow, newLine.clone(true));
+      buffer.lines.set(bottomRow, newLine);
     }
 
     // Move the viewport to the bottom of the buffer unless the user is