Skip to content

Column freezing

Lock the position of specified columns, keeping them visible when scrolling.

Overview

Column freezing locks specific columns of a grid in place, keeping them visible while scrolling to another area of the grid. We refer to frozen columns as fixed.

You can freeze columns at the start or at the end of the grid. You can freeze them during initialization and by the user.

Freeze columns at initialization

To freeze columns at initialization, use the fixedColumnsStart option. Then, configure the container of your grid with the following CSS attributes: width and overflow: hidden.

If your layout direction is ltr, columns get frozen from the left side of the table. If your layout direction is rtl, columns get frozen from the right side of the table.

JavaScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
// generate an array of arrays with dummy data
const data = new Array(100) // number of rows
.fill(null)
.map((_, row) =>
new Array(50) // number of columns
.fill(null)
.map((_, column) => `${row}, ${column}`)
);
const container = document.querySelector('#example1');
new Handsontable(container, {
data,
colWidths: 100,
width: '100%',
height: 320,
rowHeaders: true,
colHeaders: true,
fixedColumnsStart: 1,
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});
TypeScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
// generate an array of arrays with dummy data
const data: string[][] = new Array(100) // number of rows
.fill(null)
.map((_, row) =>
new Array(50) // number of columns
.fill(null)
.map((_, column) => `${row}, ${column}`)
);
const container = document.querySelector('#example1')!;
new Handsontable(container, {
data,
colWidths: 100,
width: '100%',
height: 320,
rowHeaders: true,
colHeaders: true,
fixedColumnsStart: 1,
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});

Freeze columns by dragging

To let users change the number of frozen columns and rows by dragging, enable the freezeBar option. The FreezeBar plugin draws a bar on each edge of the frozen area. Drag the bar to the column or row boundary where you want the freeze line.

  • The grid snaps the bar to whole columns and rows. A count that grows is limited to the number of columns and rows that leave room to scroll, with the band on the opposite edge taken into account. A count you configured that does not fit stays as it is, and the bar does not change it.
  • When a drag starts, the grid scrolls to the start of that axis (to the end for the bottom and end bars), so the rows or columns that get frozen are the ones on screen.
  • The bar never moves a column. It changes how many of the first (or last) columns are frozen.
  • An edge with nothing frozen has a handle on a corner of the headers, and it stays in place while the grid scrolls. The empty start and top edges can be grabbed along their whole length, so users can start freezing from there, but only the short piece on the corner is drawn. The empty end and bottom edges have only that short piece.
  • The bar is gray, and the cursor over it is an open hand that closes while you drag. When you hover the bar, its part over the headers turns a darker gray, and when you press it, that part takes the accent color. To change the colors, set the --ht-freeze-bar-color, --ht-freeze-bar-hover-color, and --ht-freeze-bar-highlight-color CSS variables (see Theme customization).
  • During a drag, a light shadow of the bar follows the pointer, and a gray shadow shows where the bar lands. Both shadows are drawn in the accent color over the headers. The bar stays where it is until you release it.
  • Press Escape during a drag to cancel it.
  • To use the keyboard, press F6 in the grid to focus the first bar, and F6 again (or Shift+F6) to move to the next (or the previous) bar. Then press the Arrow keys to change the count by one, Home to unfreeze, or End to freeze as many as fit. The drawn bar is hidden from assistive technologies. A visually hidden separator next to the grid carries the role, the label, and the aria-valuenow, aria-valuemin, and aria-valuemax attributes, and it is the one that takes the focus. Only one of the four is a Tab stop, because F6 is the way to move between them.
  • When the Pagination plugin is on, the bars for rows are hidden, because Pagination doesn’t support frozen rows.

The bars cover all four edges: fixedColumnsStart, fixedColumnsEnd, fixedRowsTop, and fixedRowsBottom. To show the bars for columns only, pass { rows: false } to the option.

JavaScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
// generate an array of arrays with dummy data
const data = new Array(100) // number of rows
.fill(null)
.map((_, row) =>
new Array(50) // number of columns
.fill(null)
.map((_, column) => `${row}, ${column}`)
);
const container = document.querySelector('#example6');
new Handsontable(container, {
data,
colWidths: 100,
width: '100%',
height: 320,
rowHeaders: true,
colHeaders: true,
fixedColumnsStart: 1,
fixedRowsTop: 1,
freezeBar: true,
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});
TypeScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
// generate an array of arrays with dummy data
const data: string[][] = new Array(100) // number of rows
.fill(null)
.map((_, row) =>
new Array(50) // number of columns
.fill(null)
.map((_, column) => `${row}, ${column}`)
);
const container = document.querySelector('#example6')!;
new Handsontable(container, {
data,
colWidths: 100,
width: '100%',
height: 320,
rowHeaders: true,
colHeaders: true,
fixedColumnsStart: 1,
fixedRowsTop: 1,
freezeBar: true,
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});

Keep your own state in sync

The plugin changes the frozen counts on the grid. It doesn’t write them back to the settings you passed in. If your application keeps the counts in its own state, copy the new count in the afterFreezeChange hook. A framework that sends the same value again on the next render doesn’t undo the change the user made.

afterFreezeChange reports the changes the bar makes. Other code changes the same counts without it: undo and redo restore them, and alter() and the ManualColumnFreeze plugin write them as well. An app that copies the counts in the hook can therefore hold a count the grid no longer shows after Ctrl+Z. To keep your state exact, read the count with getFreezeCount() after those actions, for example in the afterUndo and afterRedo hooks.

A tab switch in the sheets bar changes the counts without afterFreezeChange too: each sheet keeps its own frozen rows and columns. Read the counts with getFreezeCount() in the afterSheetTabStateRestore hook.

The settings you passed in do not follow the bar, and the other way round: a change you make with updateSettings() wins only when its value differs from the one you passed before. After a drag to 3 frozen rows, updateSettings({ fixedRowsTop: 0 }) does nothing when your own value is already 0, and updateSettings({ pagination: true }) is refused while the rows stay frozen. To take the counts back, call setFreezeCount().

To veto a request, use the beforeFreezeChange hook. It receives the edge (top, bottom, start, or end), the new and the current count, and the source of the change (drag, keyboard, or api). Return false to cancel the change.

When you turn the option off, the bars disappear and the frozen area stays as the user left it.

You can also read and set the counts with the getFreezeCount() and setFreezeCount() methods.

Freeze columns at the end

To freeze the last columns of the grid, use the fixedColumnsEnd option. The frozen columns stay at the end edge of the grid while the rest of the grid scrolls horizontally. The default value is 0.

The end edge depends on your layout direction:

  • If the layout direction is ltr, the end edge is the right side of the grid.
  • If the layout direction is rtl, the end edge is the left side of the grid.

fixedColumnsEnd counts from the last column. For example, fixedColumnsEnd: 2 freezes the last two columns of the grid.

You can combine fixedColumnsEnd with fixedColumnsStart. The following example freezes the first column (SKU) and the last column (Total):

JavaScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
// units sold per SKU and month, with the yearly total in the last column
const data = Array.from({ length: 100 }, (_, row) => {
const units = months.map((_, month) => 120 + ((row * 37 + month * 53) % 380));
return [`SKU-${4000 + row}`, ...units, units.reduce((sum, value) => sum + value, 0)];
});
const container = document.querySelector('#example3');
new Handsontable(container, {
data,
colHeaders: ['SKU', ...months, 'Total'],
colWidths: 100,
width: '100%',
height: 320,
rowHeaders: true,
fixedColumnsStart: 1,
fixedColumnsEnd: 1,
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});
TypeScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
// units sold per SKU and month, with the yearly total in the last column
const data: (string | number)[][] = Array.from({ length: 100 }, (_, row) => {
const units = months.map((_, month) => 120 + ((row * 37 + month * 53) % 380));
return [`SKU-${4000 + row}`, ...units, units.reduce((sum, value) => sum + value, 0)];
});
const container = document.querySelector('#example3')!;
new Handsontable(container, {
data,
colHeaders: ['SKU', ...months, 'Total'],
colWidths: 100,
width: '100%',
height: 320,
rowHeaders: true,
fixedColumnsStart: 1,
fixedColumnsEnd: 1,
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});

Freeze all four edges

Combine fixedColumnsStart and fixedColumnsEnd with fixedRowsTop and fixedRowsBottom to freeze every edge of the grid. For more about frozen rows, see Row freezing.

In the following example, the first row (Target) and the last row (Total) stay at the top and bottom edges. The first column (SKU) and the last column (Total) stay at the start and end edges:

JavaScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
// units sold per SKU and month, with the yearly total in the last column
const skus = Array.from({ length: 60 }, (_, row) => months.map((_, month) => 120 + ((row * 37 + month * 53) % 380)));
const sum = (values) => values.reduce((total, value) => total + value, 0);
const monthTotals = months.map((_, month) => sum(skus.map((units) => units[month])));
const data = [
['Target', ...months.map(() => 18000), 216000],
...skus.map((units, row) => [`SKU-${4000 + row}`, ...units, sum(units)]),
['Total', ...monthTotals, sum(monthTotals)],
];
const container = document.querySelector('#example4');
new Handsontable(container, {
data,
colHeaders: ['SKU', ...months, 'Total'],
colWidths: 100,
width: '100%',
height: 320,
rowHeaders: true,
fixedRowsTop: 1,
fixedRowsBottom: 1,
fixedColumnsStart: 1,
fixedColumnsEnd: 1,
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});
TypeScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
// units sold per SKU and month, with the yearly total in the last column
const skus: number[][] = Array.from({ length: 60 }, (_, row) =>
months.map((_, month) => 120 + ((row * 37 + month * 53) % 380))
);
const sum = (values: number[]) => values.reduce((total, value) => total + value, 0);
const monthTotals = months.map((_, month) => sum(skus.map((units) => units[month])));
const data: (string | number)[][] = [
['Target', ...months.map(() => 18000), 216000],
...skus.map((units, row) => [`SKU-${4000 + row}`, ...units, sum(units)]),
['Total', ...monthTotals, sum(monthTotals)],
];
const container = document.querySelector('#example4')!;
new Handsontable(container, {
data,
colHeaders: ['SKU', ...months, 'Total'],
colWidths: 100,
width: '100%',
height: 320,
rowHeaders: true,
fixedRowsTop: 1,
fixedRowsBottom: 1,
fixedColumnsStart: 1,
fixedColumnsEnd: 1,
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});

How fixedColumnsEnd interacts with other settings

  • Overlap. If fixedColumnsStart and fixedColumnsEnd together exceed the number of columns, fixedColumnsStart takes priority. Handsontable DataGrid reduces the end columns to the columns that remain. The fixedColumnsEnd value you set doesn’t change.

  • Hidden and trimmed columns. A hidden column keeps its slot in the end band. See Hidden columns. A trimmed column gives up its slot. When you trim a column inside the band, the column before the band moves in and the frozen area keeps its size.

  • Size limit. The frozen area size limit applies to the start and end columns together. Keep the combined width of all frozen columns smaller than the width of the grid.

  • Changing the value. You can change fixedColumnsEnd at any time with updateSettings(). When you remove columns that belong to the end band, Handsontable lowers the value by the number of removed frozen columns.

  • Inserted columns. An explicit insert doesn’t move the end band, the same way inserting a row doesn’t move fixedRowsBottom. The band is always the last fixedColumnsEnd columns. A column you insert inside the band, or after it (for example with Insert column right on the last end column, or alter('insert_col_end')), takes a frozen slot, and the first column of the band becomes scrollable. To keep the same columns frozen, raise fixedColumnsEnd yourself, for example in the afterCreateCol hook.

  • Spare and minimum columns. While fixedColumnsEnd is above 0, Handsontable doesn’t add empty columns for minSpareCols or minCols. A column added after the last end column would take over the frozen position and unfreeze the column that holds your data. Pressing Enter or Tab at the last column doesn’t add a column either.

  • End, Ctrl+End, and Shift+End. End and Ctrl+End go to the last column that isn’t frozen at the end, and Shift+End extends the selection to that column. They don’t move into the end columns. To reach the end columns, use the arrow keys or Tab. If the start and end columns cover every column of the grid, these shortcuts do nothing.

Known limitations

  • ManualColumnFreeze freezes and unfreezes columns on the start side only. It doesn’t change fixedColumnsEnd.
  • XLSX export and import don’t carry frozen end columns. See What is written.
  • You can’t move a column across the boundary between the scrollable columns and the frozen end columns with manualColumnMove.

Hidden columns

A column hidden with the HiddenColumns plugin keeps its slot in the frozen area. This applies to both fixedColumnsStart and fixedColumnsEnd. Hiding a column inside the frozen area shrinks the frozen area by that column, and no other column moves in.

  • Start columns. The frozen area is always the first fixedColumnsStart columns, hidden ones included. With fixedColumnsStart: 3 and column 1 hidden, the grid freezes 2 visible columns: columns 0 and 2.
  • End columns. The frozen area is always the last fixedColumnsEnd columns, hidden ones included.

To keep a set number of visible columns frozen, raise the option by the number of hidden columns inside the frozen area. Hidden rows work the same way. See Row freezing: Hidden rows.

User-triggered freeze

To enable manual column freezing, set manualColumnFreeze to true. This lets you freeze and unfreeze columns by using the grid’s context menu or column menu.

When you unfreeze a column, it moves to the first position after the remaining frozen columns. To move it back to its place in the data source order instead, see Restore the column position on unfreeze.

JavaScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
// generate an array of arrays with dummy data
const data = new Array(100) // number of rows
.fill(null)
.map((_, row) =>
new Array(50) // number of columns
.fill(null)
.map((_, column) => `${row}, ${column}`)
);
const container = document.querySelector('#example2');
new Handsontable(container, {
data,
colWidths: 100,
width: '100%',
height: 320,
rowHeaders: true,
colHeaders: true,
fixedColumnsStart: 2,
contextMenu: true,
manualColumnFreeze: true,
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});
TypeScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
// generate an array of arrays with dummy data
const data: string[][] = new Array(100) // number of rows
.fill(null)
.map((_, row) =>
new Array(50) // number of columns
.fill(null)
.map((_, column) => `${row}, ${column}`)
);
const container = document.querySelector('#example2')!;
new Handsontable(container, {
data,
colWidths: 100,
width: '100%',
height: 320,
rowHeaders: true,
colHeaders: true,
fixedColumnsStart: 2,
contextMenu: true,
manualColumnFreeze: true,
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});

Move columns across the freeze line

With manualColumnMove enabled, you can drag columns across the freeze line, in either direction, and reorder the frozen columns. Freezing works by position: the first fixedColumnsStart columns are frozen, whichever columns they are. When you drop a column in front of a frozen column, the column you dropped becomes frozen, and the last frozen column becomes scrollable. When you drag a frozen column out of the frozen area, the next column becomes frozen. The number of frozen columns stays the same.

This works the same way whether you freeze columns with fixedColumnsStart or with manualColumnFreeze.

To keep the frozen columns in place, reject those moves in the beforeColumnMove hook. Use a regular function, not an arrow function, so that this is the Handsontable instance in every framework:

beforeColumnMove: function(movedColumns, finalIndex) {
const frozenCount = this.getSettings().fixedColumnsStart ?? 0;
// reject a drop in front of a frozen column, and any move of a frozen column
if (finalIndex < frozenCount || movedColumns.some((column) => column < frozenCount)) {
return false;
}
// return nothing otherwise: any other value is passed on to the next `beforeColumnMove` handler
},

Restore the column position on unfreeze

To move an unfrozen column back to its place in the data source order, set manualColumnFreeze to an object with restoreColumnPosition set to true:

manualColumnFreeze: {
restoreColumnPosition: true,
},

The unfrozen column goes back among the scrollable columns, right after the last scrollable column that comes before it in the data source. For example, if you freeze the sixth column and then unfreeze it, it goes back between the fifth and the seventh column. If no scrollable column comes before it in the data source, it becomes the first scrollable column. It never enters the columns frozen with fixedColumnsEnd.

Handsontable doesn’t remember where the column was when you froze it: the position comes from the data source order, which is the physical column order. A column order that the grid starts with, for example from a manualColumnMove array or a saved state, counts as a move, and so does the order of your columns array: the unfrozen column goes back by the physical order, not by that order. So if you moved the column before you froze it, or reordered columns while it was frozen, the unfrozen column goes back next to the column that comes before it in the data source, not to the place you moved it to.

In the following example, freeze and unfreeze a column by using the context menu:

JavaScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
const colHeaders = [
'SKU',
'Product',
'Category',
'Supplier',
'Warehouse',
'In stock',
'Unit price',
'Rating',
'Last restock',
'Status',
];
// inventory data
const data = [
[
'KB-1042',
'Mechanical Keyboard',
'Electronics',
'Alpine Supply Co.',
'Seattle',
142,
89.99,
4.6,
'2025-03-14',
'Active',
],
[
'WB-0093',
'Stainless Steel Water Bottle',
'Drinkware',
'Harbor Goods',
'Denver',
67,
24.5,
4.8,
'2025-04-02',
'Active',
],
[
'MS-2210',
'Wireless Mouse',
'Electronics',
'Alpine Supply Co.',
'Austin',
0,
34.99,
4.3,
'2025-01-27',
'Discontinued',
],
['BP-4821', 'Waterproof Backpack', 'Apparel', 'Northwind Traders', 'Portland', 38, 79, 4.5, '2025-05-19', 'Active'],
['DL-3307', 'LED Desk Lamp', 'Home Office', 'Harbor Goods', 'Denver', 215, 42.75, 4.1, '2025-02-08', 'Active'],
];
const container = document.querySelector('#example5');
new Handsontable(container, {
data,
colHeaders,
colWidths: 110,
width: '100%',
height: 'auto',
rowHeaders: true,
contextMenu: true,
manualColumnMove: true,
manualColumnFreeze: {
restoreColumnPosition: true,
},
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});
TypeScript
import Handsontable from 'handsontable/base';
import { registerAllModules } from 'handsontable/registry';
// Register all Handsontable's modules.
registerAllModules();
const colHeaders = ['SKU', 'Product', 'Category', 'Supplier', 'Warehouse', 'In stock', 'Unit price', 'Rating', 'Last restock', 'Status'];
// inventory data
const data: (string | number)[][] = [
['KB-1042', 'Mechanical Keyboard', 'Electronics', 'Alpine Supply Co.', 'Seattle', 142, 89.99, 4.6, '2025-03-14', 'Active'],
['WB-0093', 'Stainless Steel Water Bottle', 'Drinkware', 'Harbor Goods', 'Denver', 67, 24.5, 4.8, '2025-04-02', 'Active'],
['MS-2210', 'Wireless Mouse', 'Electronics', 'Alpine Supply Co.', 'Austin', 0, 34.99, 4.3, '2025-01-27', 'Discontinued'],
['BP-4821', 'Waterproof Backpack', 'Apparel', 'Northwind Traders', 'Portland', 38, 79, 4.5, '2025-05-19', 'Active'],
['DL-3307', 'LED Desk Lamp', 'Home Office', 'Harbor Goods', 'Denver', 215, 42.75, 4.1, '2025-02-08', 'Active'],
];
const container = document.querySelector('#example5')!;
new Handsontable(container, {
data,
colHeaders,
colWidths: 110,
width: '100%',
height: 'auto',
rowHeaders: true,
contextMenu: true,
manualColumnMove: true,
manualColumnFreeze: {
restoreColumnPosition: true,
},
autoWrapRow: true,
autoWrapCol: true,
// licenseKey: 'your-license-key', // get a key at https://handsontable.com/pricing/
});

Frozen area size limit

By default, Handsontable draws frozen columns in full. It never shrinks them, and it never scrolls them. If the frozen columns need more space than the grid has, they cover the whole grid. The remaining columns stay out of reach: the horizontal scrollbar still moves, but the view no longer changes.

This applies to the total width of the frozen columns, not to how many there are. A single frozen column that you resize wider than the grid causes the same result.

To keep the rest of the grid reachable, set the limitFixedToViewport option to true:

fixedColumnsStart: 20,
fixedColumnsEnd: 2,
limitFixedToViewport: true,

With this option on, Handsontable draws only as many frozen columns as fit and keeps a strip of the grid scrollable. The option changes what the grid draws, not what you configured:

  • getSettings() still returns the values of fixedColumnsStart and fixedColumnsEnd.
  • Handsontable measures the grid again when it resizes. The frozen columns come back when the grid grows.
  • A strip of at least 40 px stays scrollable.
  • The start columns have priority over the end columns. When the start columns fill the grid, the end columns are not drawn as frozen at all.
  • When a user drags a FreezeBar bar, the new count replaces the configured one, and the frozen area no longer returns when the grid grows. getFreezeCount() reports the configured count, so an app that saves it keeps the value that was set.
  • The FreezeBar plugin shows the bar on the line where the drawn frozen area ends.
  • ManualColumnFreeze works on the columns the grid draws as frozen. A column that scrolls is not offered Unfreeze. Freeze is hidden, and freezeColumn() does nothing, when one more frozen column would not fit, so the plugin never freezes a column that keeps scrolling. Unfreeze replaces the configured count with the drawn count minus one, as a bar drag does, so the frozen area no longer returns when the grid grows.

The option works the same way for frozen rows. Read more in Row freezing.

If you leave the option off, keep the combined width of your frozen columns smaller than the width of the grid. If your grid has to work at several sizes, pick a number of frozen columns that fits the narrowest one.

Configuration options

Plugins

Hooks