{"id":20,"date":"2026-04-30T11:05:00","date_gmt":"2026-04-30T11:05:00","guid":{"rendered":"https:\/\/wisegrid.co\/blog\/smartsheet-formulas-translation-guide\/"},"modified":"2026-06-10T16:23:26","modified_gmt":"2026-06-10T16:23:26","slug":"smartsheet-formulas-translation-guide","status":"publish","type":"post","link":"https:\/\/wisegrid.co\/blog\/smartsheet-formulas-translation-guide\/","title":{"rendered":"Formulas in Wisegrid \u2014 the Same `[Column]@row` Syntax You Know from Smartsheet"},"content":{"rendered":"<p><em>By <a href=\"\/blog\/author\/ryan-kramer\/\">Ryan Kramer<\/a>, founder of Wisegrid. Last updated June 2026.<\/em><\/p>\n<p>If you\u2019re coming from Smartsheet, the thing you\u2019re most afraid of losing is your formulas \u2014 the <code>[Column Name]@row<\/code> references, the <code>VLOOKUP<\/code>s, the <code>INDEX\/MATCH<\/code> you\u2019ve leaned on for years. Here\u2019s the short version: <strong>Wisegrid speaks the same formula language.<\/strong> Same-row references use the exact same <code>[Column Name]@row<\/code> syntax, the function names and behavior are the same, and the one place the two genuinely diverge \u2014 cross-sheet references \u2014 is a place where Wisegrid is <em>easier<\/em>, not harder.<\/p>\n<p>This guide is written Wisegrid-first: here\u2019s how formulas work in our grid, with a note alongside each one for anyone migrating from Smartsheet. At the end, there\u2019s an honest scorecard of what the <a href=\"\/migrate\">Smartsheet importer<\/a> carries across automatically and the handful of functions (like <code>LET<\/code> and <code>LAMBDA<\/code>) that aren\u2019t supported yet.<\/p>\n<blockquote>\n<p><strong>Key takeaways<\/strong> \u2013 <strong>Same-row references are identical.<\/strong> <code>[Column Name]@row<\/code> means the same thing in Wisegrid as in Smartsheet \u2014 and it comes across a migration <strong>unchanged<\/strong>, not rewritten into <code>B4<\/code>. \u2013 <strong>The functions are the same.<\/strong> <code>SUM<\/code>, <code>IF<\/code>, <code>VLOOKUP<\/code>, <code>COUNTIF<\/code>, <code>XLOOKUP<\/code>, <code>INDEX<\/code>, <code>MATCH<\/code> \u2014 same names, same behavior. \u2013 **Cross-sheet references are where Wisegrid is <em>better<\/em>.<strong> Instead of a modal-picked <code>{Reference Name}<\/code> object you ration against a 100-per-sheet cap, you type <code>=[Sheet]!A1<\/code> inline. No modal, no cap. \u2013 <\/strong>Column-wide references use standard <code>E:E<\/code> cell ranges<strong> \u2014 the one syntactic shift, and only for whole-column \/ specific-row references, never for same-row. \u2013 <\/strong><code>FILTER<\/code>, <code>SORT<\/code>, <code>UNIQUE<\/code>, <code>LET<\/code>, and <code>LAMBDA<\/code> aren\u2019t supported yet<strong> \u2014 they\u2019re flagged for manual review on import rather than silently miscalculated. \u2013 <\/strong>Hierarchy functions (<code>CHILDREN<\/code>\/<code>PARENT<\/code>\/<code>ANCESTORS<\/code>\/<code>DESCENDANTS<\/code>) work the same way** \u2014 same row hierarchy, same rollups.<\/p>\n<\/blockquote>\n<nav class=\"wg-toc\" aria-label=\"Table of contents\"><div class=\"wg-toc-eyebrow\"><span class=\"lp-dot\" aria-hidden=\"true\"><\/span> On this page<\/div><ul>\n<li><a href=\"#how-a-wisegrid-formula-is-built\">How a Wisegrid formula is built<\/a><\/li>\n<li><a href=\"#references-column-row-and-the-rest\">References: <code>[Column]@row<\/code> and the rest<\/a><\/li>\n<li><a href=\"#common-functions\">Common functions<\/a><\/li>\n<li><a href=\"#lookups-vlookup-indexmatch-and-the-modern-set\">Lookups: VLOOKUP, INDEX\/MATCH, and the modern set<\/a><\/li>\n<li><a href=\"#cross-sheet-formulas-where-wisegrid-is-easier\">Cross-sheet formulas: where Wisegrid is easier<\/a><\/li>\n<li><a href=\"#hierarchy-formulas-children-parent-ancestors\">Hierarchy formulas (CHILDREN, PARENT, ANCESTORS)<\/a><\/li>\n<li><a href=\"#migrating-from-smartsheet-what-carries-across\">Migrating from Smartsheet: what carries across<\/a><\/li>\n<li><a href=\"#faq\">FAQ<\/a><\/li>\n<\/ul><\/nav>\n<h2 id=\"how-a-wisegrid-formula-is-built\">How a Wisegrid formula is built<\/h2>\n<p>A Wisegrid formula has two kinds of pieces, exactly like Smartsheet:<\/p>\n<ol>\n<li><strong>Functions<\/strong> \u2014 <code>SUM<\/code>, <code>IF<\/code>, <code>VLOOKUP<\/code>, <code>COUNTIF<\/code>, and the rest. Same names, same behavior. If you know them from Smartsheet (or Excel), you already know them here.<\/li>\n<li><strong>References<\/strong> \u2014 how the formula points at data. This is the part that <em>looks<\/em> like a dialect, and the good news is Wisegrid uses the same dialect Smartsheet does for the common case:<\/li>\n<\/ol>\n<ul>\n<li><code>[Column Name]@row<\/code> \u2014 the value of that column <strong>in the current row<\/strong> (the workhorse \u2014 identical to Smartsheet)<\/li>\n<li><code>D5<\/code> \u2014 a specific cell, by standard A1 address<\/li>\n<li><code>D:D<\/code> \u2014 a whole column<\/li>\n<li><code>[Sheet]!A1<\/code> \u2014 a cell on another sheet, typed inline<\/li>\n<\/ul>\n<p>So a Wisegrid formula like <code>=[Hours]@row * [Rate]@row<\/code> reads as \u201cthis row\u2019s Hours times this row\u2019s Rate\u201d \u2014 the same formula you\u2019d write in Smartsheet, character for character. The engine resolves <code>[Hours]@row<\/code> to the right cell on whatever row the formula lives in, and it survives column reordering because it points at the column by <strong>name<\/strong>, not by letter.<\/p>\n<h2 id=\"references-columnrow-and-the-rest\">References: <code>[Column]@row<\/code> and the rest<\/h2>\n<p>Here\u2019s every reference shape, Wisegrid-first, with the Smartsheet equivalent for anyone migrating:<\/p>\n<div class=\"wg-table-wrap\"><table>\n<thead>\n<tr>\n<th>What you\u2019re referencing<\/th>\n<th class=\"wg-col-win\">In Wisegrid<\/th>\n<th>Coming from Smartsheet<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>This row\u2019s value in a column<\/td>\n<td class=\"wg-col-win\"><code>[Status]@row<\/code><\/td>\n<td><strong>Identical<\/strong> \u2014 same <code>[Status]@row<\/code><\/td>\n<\/tr>\n<tr>\n<td>A specific row\u2019s value<\/td>\n<td class=\"wg-col-win\"><code>D5<\/code><\/td>\n<td>was <code>[Status]5<\/code><\/td>\n<\/tr>\n<tr>\n<td>A whole column<\/td>\n<td class=\"wg-col-win\"><code>D:D<\/code><\/td>\n<td>was <code>[Status]<\/code> or <code>[Status]:[Status]<\/code><\/td>\n<\/tr>\n<tr>\n<td>A range across columns<\/td>\n<td class=\"wg-col-win\"><code>D:E<\/code><\/td>\n<td>was <code>[Status]:[Amount]<\/code><\/td>\n<\/tr>\n<tr>\n<td>A cell on another sheet<\/td>\n<td class=\"wg-col-win\"><code>[Q1 Sales]!A1:Z100<\/code><\/td>\n<td>was <code>{Q1 Sales}<\/code> \u2014 a modal-picked named object<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/div>\n<p>The headline: <strong>the reference you\u2019ll write 90% of the time \u2014 <code>[Column Name]@row<\/code> \u2014 is the same in both tools.<\/strong> It\u2019s also genuinely the nicer way to write a same-row reference: <code>[Hours]@row * [Rate]@row<\/code> is self-documenting in a way <code>=B4*C4<\/code> never is, and it doesn\u2019t break when you drag a column to a new position. We kept it on purpose.<\/p>\n<p>Where Wisegrid uses standard cell addresses \u2014 whole columns (<code>D:D<\/code>), specific rows (<code>D5<\/code>), cross-column ranges (<code>D:E<\/code>) \u2014 it\u2019s because those are the lingua franca of spreadsheets and what most people already expect. Same-row stays named; the rest is plain A1.<\/p>\n<h2 id=\"common-functions\">Common functions<\/h2>\n<p>The everyday functions are the same name and the same behavior. Anything that operates on the <strong>current row<\/strong> is character-for-character identical to Smartsheet; the only shift is that <strong>column-wide<\/strong> references become standard <code>E:E<\/code>-style ranges.<\/p>\n<div class=\"wg-table-wrap\"><table>\n<thead>\n<tr>\n<th>Function<\/th>\n<th class=\"wg-col-win\">In Wisegrid<\/th>\n<th>Same as Smartsheet?<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>IF<\/code><\/td>\n<td class=\"wg-col-win\"><code>=IF([Status]@row=\"Done\", 1, 0)<\/code><\/td>\n<td>\u2705 Identical<\/td>\n<\/tr>\n<tr>\n<td><code>CONCAT<\/code><\/td>\n<td class=\"wg-col-win\"><code>=CONCAT([First]@row, \" \", [Last]@row)<\/code><\/td>\n<td>\u2705 Identical<\/td>\n<\/tr>\n<tr>\n<td><code>IFERROR<\/code><\/td>\n<td class=\"wg-col-win\"><code>=IFERROR([Rate]@row, 0)<\/code><\/td>\n<td>\u2705 Identical<\/td>\n<\/tr>\n<tr>\n<td><code>SUM<\/code><\/td>\n<td class=\"wg-col-win\"><code>=SUM(E:E)<\/code><\/td>\n<td>column ref <code>[Amount]:[Amount]<\/code> \u2192 <code>E:E<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>COUNTIF<\/code><\/td>\n<td class=\"wg-col-win\"><code>=COUNTIF(D:D, \"Done\")<\/code><\/td>\n<td>column ref <code>[Status]:[Status]<\/code> \u2192 <code>D:D<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>SUMIF<\/code><\/td>\n<td class=\"wg-col-win\"><code>=SUMIF(D:D, \"Paid\", E:E)<\/code><\/td>\n<td>column refs \u2192 <code>D:D<\/code>, <code>E:E<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>AVERAGE<\/code> \/ <code>AVG<\/code><\/td>\n<td class=\"wg-col-win\"><code>=AVG(E:E)<\/code><\/td>\n<td>column ref <code>[Amount]:[Amount]<\/code> \u2192 <code>E:E<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/div>\n<p><em>(Examples assume Status is column D and Amount is column E.)<\/em><\/p>\n<p>The pattern holds for the long tail too \u2014 text functions (<code>LEFT<\/code>, <code>RIGHT<\/code>, <code>MID<\/code>, <code>LEN<\/code>, <code>SUBSTITUTE<\/code>), math (<code>ROUND<\/code>, <code>CEILING<\/code>, <code>FLOOR<\/code>, <code>MOD<\/code>, <code>POWER<\/code>), date math (<code>NETWORKDAY<\/code>, <code>WORKDAY<\/code>, <code>EOMONTH<\/code>, <code>DATEDIF<\/code>), and logical (<code>AND<\/code>, <code>OR<\/code>, <code>NOT<\/code>, <code>IFS<\/code>, <code>SWITCH<\/code>). The function never changes; only a whole-column reference swaps <code>[Column]:[Column]<\/code> for <code>E:E<\/code>.<\/p>\n<p><strong>The honest exception: <code>LET<\/code> and <code>LAMBDA<\/code>.<\/strong> Wisegrid\u2019s engine doesn\u2019t evaluate them yet, so on import they aren\u2019t force-fed through and rendered as a wrong value \u2014 they\u2019re routed to the review queue with their original syntax intact, so you can rebuild them deliberately. If your sheets lean heavily on <code>LET<\/code>\/<code>LAMBDA<\/code>, know that going in.<\/p>\n<h2 id=\"lookups-vlookup-indexmatch-and-the-modern-set\">Lookups: VLOOKUP, INDEX\/MATCH, and the modern set<\/h2>\n<p>Lookups are the formulas people worry about most, because a broken lookup quietly corrupts a whole column. The honest status: <strong>all the common lookups work, and the modern lookup family is supported.<\/strong> The lookup <em>value<\/em> is usually a same-row <code>[SKU]@row<\/code> (identical to Smartsheet); the lookup <em>table<\/em> is the one part that changes \u2014 a Smartsheet <code>{Reference Name}<\/code> becomes a typed <code>[Sheet]!range<\/code>.<\/p>\n<div class=\"wg-table-wrap\"><table>\n<thead>\n<tr>\n<th>Lookup<\/th>\n<th class=\"wg-col-win\">In Wisegrid<\/th>\n<th>Supported?<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>VLOOKUP<\/code><\/td>\n<td class=\"wg-col-win\"><code>=VLOOKUP([SKU]@row, [Price Table]!A1:Z100, 2, false)<\/code><\/td>\n<td>\u2705<\/td>\n<\/tr>\n<tr>\n<td><code>HLOOKUP<\/code><\/td>\n<td class=\"wg-col-win\"><code>=HLOOKUP([Key]@row, [Rates]!A1:Z100, 3, false)<\/code><\/td>\n<td>\u2705<\/td>\n<\/tr>\n<tr>\n<td><code>INDEX<\/code> \/ <code>MATCH<\/code><\/td>\n<td class=\"wg-col-win\"><code>=INDEX([Prices]!A1:Z100, MATCH([SKU]@row, [SKUs]!A1:Z100, 0))<\/code><\/td>\n<td>\u2705<\/td>\n<\/tr>\n<tr>\n<td><code>XLOOKUP<\/code><\/td>\n<td class=\"wg-col-win\"><code>=XLOOKUP([SKU]@row, [SKUs]!A1:Z100, [Prices]!A1:Z100)<\/code><\/td>\n<td>\u2705<\/td>\n<\/tr>\n<tr>\n<td><code>XMATCH<\/code><\/td>\n<td class=\"wg-col-win\"><code>=XMATCH([SKU]@row, [SKUs]!A1:Z100)<\/code><\/td>\n<td>\u2705<\/td>\n<\/tr>\n<tr>\n<td><code>LOOKUP<\/code><\/td>\n<td class=\"wg-col-win\"><code>=LOOKUP([SKU]@row, [Table]!A1:Z100)<\/code><\/td>\n<td>\u2705<\/td>\n<\/tr>\n<tr>\n<td><code>FILTER<\/code><\/td>\n<td class=\"wg-col-win\"><code>=FILTER(...)<\/code><\/td>\n<td>\u274c not yet (needs dynamic arrays)<\/td>\n<\/tr>\n<tr>\n<td><code>SORT<\/code> \/ <code>UNIQUE<\/code><\/td>\n<td class=\"wg-col-win\"><code>=UNIQUE(...)<\/code><\/td>\n<td>\u274c not yet (needs dynamic arrays)<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/div>\n<p><code>XLOOKUP<\/code>, <code>XMATCH<\/code>, <code>INDEX<\/code>, <code>MATCH<\/code>, <code>VLOOKUP<\/code>, <code>HLOOKUP<\/code>, and <code>LOOKUP<\/code> all evaluate in Wisegrid\u2019s engine \u2014 that\u2019s the shipped support set, not a roadmap promise. So an <code>INDEX\/MATCH<\/code> you\u2019ve leaned on for years, or an <code>XLOOKUP<\/code> you rewrote it into, both keep working. The dynamic-array functions \u2014 <code>FILTER<\/code>, <code>SORT<\/code>, and <code>UNIQUE<\/code> \u2014 aren\u2019t supported yet (they need a spill model we haven\u2019t built), so they\u2019re flagged for manual review on import rather than silently miscalculated.<\/p>\n<h2 id=\"cross-sheet-formulas-where-wisegrid-is-easier\">Cross-sheet formulas: where Wisegrid is easier<\/h2>\n<p>This is the one place Wisegrid and Smartsheet genuinely diverge \u2014 and it\u2019s the place Wisegrid is <em>better<\/em>.<\/p>\n<p>In Smartsheet, a cross-sheet formula doesn\u2019t point at another sheet inline. You open a <strong>reference-picker modal<\/strong>, select a range on another sheet, give that selection a <strong>name<\/strong>, and Smartsheet stores it as a <code>{Reference Name}<\/code> object you then use in formulas. It works, but it has real ceilings: <strong>a sheet can include no more than 100 distinct cross-sheet references<\/strong>, and <strong>large-scale sheets can\u2019t be used in cross-sheet references at all<\/strong> (both per <a href=\"https:\/\/help.smartsheet.com\/articles\/2482644-create-cross-sheet-references\" target=\"_blank\" rel=\"noopener\">Smartsheet\u2019s own cross-sheet reference documentation<\/a>). Every reference is a modal round-trip.<\/p>\n<p>In Wisegrid, you just type it:<\/p>\n<div class=\"wg-table-wrap\"><table>\n<thead>\n<tr>\n<th>Scenario<\/th>\n<th class=\"wg-col-win\">In Wisegrid<\/th>\n<th>Coming from Smartsheet<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Same workspace \/ project<\/td>\n<td class=\"wg-col-win\"><code>[Q1 Sales]!A1:Z100<\/code><\/td>\n<td>was <code>{Q1 Sales}<\/code><\/td>\n<\/tr>\n<tr>\n<td>Different project<\/td>\n<td class=\"wg-col-win\"><code>[FY26 Finance][Q1 Sales]!A1:Z100<\/code><\/td>\n<td>was <code>{Q1 Sales}<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/div>\n<p>No modal, no naming step, no 100-reference cap to ration. Adding a cross-sheet lookup is <code>=[Sheet]!A1<\/code> and you move on.<\/p>\n<p>When you migrate, the importer resolves each Smartsheet <code>{Reference Name}<\/code> into its typed <code>[Sheet]!range<\/code> equivalent. The honest caveat: if a <code>{Reference Name}<\/code> points at a sheet you <em>didn\u2019t<\/em> include in the migration, the importer can\u2019t bind it to a real target \u2014 so rather than emit a reference that silently resolves to nothing, it flags it in the review queue for you to decide (import that sheet too, or repoint the reference).<\/p>\n<figure><img decoding=\"async\" src=\"\/blog\/wp-content\/uploads\/2026\/06\/formula-review-queue.png\" alt=\"The Wisegrid migration report's formula review queue, listing the small number of formulas the importer flagged for a human to check, each shown with its original Smartsheet syntax and a suggested translation\" loading=\"lazy\"><figcaption>Honest by design: the importer carries the vast majority of formulas across untouched and surfaces only the ones that need a human\u2019s eye \u2014 each with its original Smartsheet syntax and a suggested fix \u2014 instead of producing silently wrong values.<\/figcaption><\/figure>\n<h2 id=\"hierarchy-formulas-children-parent-ancestors\">Hierarchy formulas (CHILDREN, PARENT, ANCESTORS)<\/h2>\n<p>Wisegrid has the same row hierarchy as Smartsheet (parent\/child indentation), and the same functions that traverse it: <code>CHILDREN<\/code>, <code>PARENT<\/code>, <code>ANCESTORS<\/code>, and <code>DESCENDANTS<\/code>. A parent row rolls up its children the same way \u2014 e.g. <code>=SUM(CHILDREN([Amount]@row))<\/code>.<\/p>\n<p>There\u2019s one small syntax difference in how you name the column being traversed: Smartsheet writes it as a bracketed reference, Wisegrid takes the <strong>column name as a quoted string<\/strong>.<\/p>\n<div class=\"wg-table-wrap\"><table>\n<thead>\n<tr>\n<th>Function<\/th>\n<th class=\"wg-col-win\">In Wisegrid<\/th>\n<th>Coming from Smartsheet<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>CHILDREN<\/code><\/td>\n<td class=\"wg-col-win\"><code>=SUM(CHILDREN(\"Amount\"))<\/code><\/td>\n<td>was <code>=SUM(CHILDREN([Amount]@row))<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>PARENT<\/code><\/td>\n<td class=\"wg-col-win\"><code>=PARENT(\"Status\")<\/code><\/td>\n<td>was <code>=PARENT([Status]@row)<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>ANCESTORS<\/code><\/td>\n<td class=\"wg-col-win\"><code>=COUNT(ANCESTORS(\"Task\"))<\/code><\/td>\n<td>was <code>=COUNT(ANCESTORS([Task]@row))<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>DESCENDANTS<\/code><\/td>\n<td class=\"wg-col-win\"><code>=SUM(DESCENDANTS(\"Amount\"))<\/code><\/td>\n<td>was <code>=SUM(DESCENDANTS([Amount]@row))<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/div>\n<p><strong>The honest limit \u2014 and it\u2019s a limit Smartsheet shares:<\/strong> hierarchy functions don\u2019t work <em>across<\/em> sheets. In Smartsheet, a <code>CHILDREN<\/code>\/<code>PARENT<\/code>\/<code>ANCESTORS<\/code> call that reaches into another sheet returns <code>#UNSUPPORTED CROSS-SHEET FORMULA<\/code> (<a href=\"https:\/\/help.smartsheet.com\/articles\/2476176-formula-error-messages\" target=\"_blank\" rel=\"noopener\">per Smartsheet\u2019s formula error message documentation<\/a>). Wisegrid has the same constraint, and the importer flags the same case for review rather than producing a wrong rollup. It\u2019s a shared limit, surfaced honestly \u2014 one more reason the <a href=\"\/blog\/smartsheet-export-what-you-lose\">500K-cell wall is worse than it sounds<\/a>, since the official \u201csplit your sheet\u201d fix breaks the cross-sheet rollups that stitch the pieces back together.<\/p>\n<h2 id=\"migrating-from-smartsheet-what-carries-across\">Migrating from Smartsheet: what carries across<\/h2>\n<p>Putting it together, here\u2019s the honest scorecard for a Smartsheet \u2192 Wisegrid migration:<\/p>\n<div class=\"wg-table-wrap\"><table>\n<thead>\n<tr>\n<th>Carries across automatically<\/th>\n<th>Needs a human look (review queue)<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>[Column Name]@row<\/code> \u2014 <strong>preserved unchanged<\/strong><\/td>\n<td>A formula referencing a column that no longer exists<\/td>\n<\/tr>\n<tr>\n<td>Specific-row <code>[Col]N<\/code> and column ranges <code>[A]:[B]<\/code> \u2192 standard <code>D5<\/code> \/ <code>D:E<\/code><\/td>\n<td><code>{Reference Name}<\/code> pointing at a sheet you didn\u2019t import<\/td>\n<\/tr>\n<tr>\n<td>All supported functions (see the lists above)<\/td>\n<td><code>LET<\/code> \/ <code>LAMBDA<\/code> (not supported yet)<\/td>\n<\/tr>\n<tr>\n<td><code>{Reference Name}<\/code> \u2192 typed <code>[Sheet]!range<\/code> when the target is imported<\/td>\n<td><code>FILTER<\/code> \/ <code>SORT<\/code> \/ <code>UNIQUE<\/code> (need dynamic arrays)<\/td>\n<\/tr>\n<tr>\n<td><code>CHILDREN<\/code>\/<code>PARENT<\/code>\/<code>ANCESTORS<\/code>\/<code>DESCENDANTS<\/code> (single-sheet)<\/td>\n<td><code>@cell<\/code> and standalone <code>@row<\/code> markers<\/td>\n<\/tr>\n<tr>\n<td>Cross-project refs <code>[Project][Sheet]!range<\/code><\/td>\n<td>Cross-sheet hierarchy (<code>#UNSUPPORTED<\/code> in Smartsheet too)<\/td>\n<\/tr>\n<\/tbody>\n<\/table><\/div>\n<p>The thing that makes this trustworthy isn\u2019t that <em>everything<\/em> converts \u2014 it\u2019s that <strong>same-row references come across exactly as you wrote them<\/strong>, and <strong>anything that can\u2019t be carried over is shown to you<\/strong>, with its original syntax and a suggested fix, instead of being passed through to render a wrong number in a cell you\u2019ll never think to check. On a real test migration we ran end-to-end, the importer mirrored <strong>4,863 rows across 14 sheets<\/strong> and carried everything across except <strong>eight items<\/strong> (five formulas, two columns, one cell) \u2014 which all landed in the review queue.<\/p>\n<p>For the full picture, the <a href=\"\/blog\/how-to-migrate-off-smartsheet\">step-by-step guide to migrating off Smartsheet<\/a> walks through the whole importer flow, and <a href=\"\/blog\/smartsheet-export-what-you-lose\">what Smartsheet\u2019s export actually loses<\/a> explains why the manual export route drops your formulas entirely (to values-only) in the first place.<\/p>\n<h2 id=\"faq\">FAQ<\/h2>\n<h3 id=\"does-wisegrid-use-the-same-formula-syntax-as-smartsheet\">Does Wisegrid use the same formula syntax as Smartsheet?<\/h3>\n<p>For the common case, yes. Same-row references use the identical <code>[Column Name]@row<\/code> syntax, and the function names and behavior are the same. The one difference is cross-sheet references: where Smartsheet uses a modal-picked <code>{Reference Name}<\/code> object, Wisegrid uses a typed <code>[Sheet]!A1<\/code> reference \u2014 with no 100-reference-per-sheet cap. Whole-column and specific-row references use standard A1 ranges (<code>D:D<\/code>, <code>D5<\/code>).<\/p>\n<h3 id=\"what-does-column-namerow-mean\">What does <code>[Column Name]@row<\/code> mean?<\/h3>\n<p>It means \u201cthe value of <em>this column<\/em> in the <em>current row<\/em>\u201d \u2014 a relative same-row reference. It works the same way in Wisegrid as in Smartsheet, and because it points at the column by <strong>name<\/strong> rather than by letter, it\u2019s self-documenting and survives column reordering. <code>[Hours]@row<\/code> resolves to the Hours cell on whatever row the formula lives in.<\/p>\n<h3 id=\"do-my-columnrow-formulas-change-when-i-migrate-from-smartsheet\">Do my <code>[Column]@row<\/code> formulas change when I migrate from Smartsheet?<\/h3>\n<p>No \u2014 same-row <code>[Column]@row<\/code> references are <strong>preserved unchanged<\/strong> on import. The formula you wrote in Smartsheet is the formula you\u2019ll see in Wisegrid. What gets rewritten is cross-sheet references (the <code>{Reference Name}<\/code> object becomes a typed <code>[Sheet]!range<\/code>) and, in aggregations, whole-column references (<code>[Amount]:[Amount]<\/code> becomes the standard <code>E:E<\/code>).<\/p>\n<h3 id=\"does-wisegrid-have-vlookup-and-indexmatch\">Does Wisegrid have VLOOKUP and INDEX\/MATCH?<\/h3>\n<p>Yes. <code>VLOOKUP<\/code>, <code>HLOOKUP<\/code>, <code>INDEX<\/code>, <code>MATCH<\/code>, plus the modern <code>XLOOKUP<\/code> and <code>XMATCH<\/code> and the classic <code>LOOKUP<\/code> all evaluate in Wisegrid\u2019s engine. A Smartsheet lookup that uses a <code>{Reference Name}<\/code> cross-sheet table comes across with that table rewritten to a typed <code>[Sheet]!range<\/code>.<\/p>\n<h3 id=\"which-smartsheet-formulas-dont-carry-across-automatically\">Which Smartsheet formulas <em>don\u2019t<\/em> carry across automatically?<\/h3>\n<p>The dynamic-array functions <code>FILTER<\/code>, <code>SORT<\/code>, and <code>UNIQUE<\/code> aren\u2019t supported yet (they need a spill model we haven\u2019t built), and neither are <code>LET<\/code> and <code>LAMBDA<\/code> \u2014 all five are flagged for manual review rather than miscalculated. Cross-sheet hierarchy functions (<code>CHILDREN<\/code>\/<code>PARENT<\/code>\/<code>ANCESTORS<\/code> reaching into another sheet) also don\u2019t translate \u2014 but those return <code>#UNSUPPORTED CROSS-SHEET FORMULA<\/code> in Smartsheet too, so it\u2019s a shared limit. And any formula referencing a missing column, an <code>@cell<\/code> marker, or a <code>{Reference Name}<\/code> whose target sheet you didn\u2019t import gets surfaced for review instead of guessed.<\/p>\n<h3 id=\"what-happens-to-formulas-the-importer-cant-carry-across\">What happens to formulas the importer can\u2019t carry across?<\/h3>\n<p>They go to a visible review queue with the <strong>original Smartsheet syntax<\/strong> and a <strong>suggested fix<\/strong>, so you handle the handful that need it instead of trusting that thousands of cells came over clean. Nothing is passed through to render a silently-wrong value.<\/p>\n<h3 id=\"how-many-cross-sheet-references-can-i-have\">How many cross-sheet references can I have?<\/h3>\n<p>In Smartsheet, a sheet can include no more than 100 distinct cross-sheet references, and large-scale sheets can\u2019t be used in cross-sheet references at all (both per <a href=\"https:\/\/help.smartsheet.com\/articles\/2482644-create-cross-sheet-references\" target=\"_blank\" rel=\"noopener\">Smartsheet\u2019s cross-sheet reference documentation<\/a>). Wisegrid has no such cap, and references are typed inline (<code>=[Sheet]!A1<\/code>) instead of built one modal at a time.<\/p>\n<hr>\n<h3 id=\"see-your-own-formulas-come-across\">See your own formulas come across<\/h3>\n<p>The cleanest way to know how <em>your<\/em> formulas migrate is to run them through the importer. Paste a read-only Smartsheet token and Wisegrid mirrors your workspace \u2014 same-row formulas preserved, the few exceptions surfaced in a review queue \u2014 at the same price you already pay.<\/p>\n<p><strong><a href=\"\/migrate\">Start your migration \u2192<\/a><\/strong> \u00b7 <a href=\"\/blog\/how-to-migrate-off-smartsheet\">How to migrate off Smartsheet \u2192<\/a> \u00b7 <a href=\"\/blog\/smartsheet-export-what-you-lose\">What Smartsheet\u2019s export loses \u2192<\/a><\/p>\n<hr>\n<blockquote>\n<p><strong>About the author<\/strong> <strong><a href=\"\/blog\/author\/ryan-kramer\/\">Ryan Kramer<\/a><\/strong> is the founder of Wisegrid, a higher-capacity Smartsheet alternative built around a 1,000,000-cell-per-sheet grid, conflict-safe collaboration, and a one-click Smartsheet importer. He built Wisegrid out of first-hand experience hitting the walls in Smartsheet\u2019s grid, pricing model, and capacity limits, and writes about leaving Smartsheet without losing your data. <a href=\"\/blog\/author\/ryan-kramer\/\">More from Ryan \u2192<\/a><\/p>\n<\/blockquote>\n","protected":false},"excerpt":{"rendered":"<p>A Smartsheet formula cheat sheet \u2014 VLOOKUP, INDEX\/MATCH, [Column Name]@row, {Reference Name}, cross-sheet refs \u2014 and how each translates when you switch.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-20","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/wisegrid.co\/blog\/wp-json\/wp\/v2\/posts\/20","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/wisegrid.co\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/wisegrid.co\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/wisegrid.co\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/wisegrid.co\/blog\/wp-json\/wp\/v2\/comments?post=20"}],"version-history":[{"count":4,"href":"https:\/\/wisegrid.co\/blog\/wp-json\/wp\/v2\/posts\/20\/revisions"}],"predecessor-version":[{"id":46,"href":"https:\/\/wisegrid.co\/blog\/wp-json\/wp\/v2\/posts\/20\/revisions\/46"}],"wp:attachment":[{"href":"https:\/\/wisegrid.co\/blog\/wp-json\/wp\/v2\/media?parent=20"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/wisegrid.co\/blog\/wp-json\/wp\/v2\/categories?post=20"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/wisegrid.co\/blog\/wp-json\/wp\/v2\/tags?post=20"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}