Excel Formula Translator

The agency works in Google Sheets. Your company lives in Excel. The formula that prices the whole engagement — built in one world, pasted into the other — lands as a wall of #NAME? and a parse error, and now the meeting is about the spreadsheet instead of the deal. It's always something small: a function that changed names between the dialects, a separator that the receiving app doesn't accept, an array formula that behaves differently on the far side. Small causes, total downtime, recurring monthly.

Hybrid Excel/Sheets workflows stopped being an edge case around 2020 and became simply how offices are. Freelancers deliver Sheets; finance consolidates in Excel; one team migrates forward while another stays on 2019 for a plugin that shall not be named. Into every hybrid flows a steady current of formulas crossing the border, and until now, every crossing was hand-carried: someone squinting at Microsoft's function list against Google's, guessing what FILTER does over there, discovering the hard way that the answer is "not that."

This translator automates the border crossing. Paste a formula, pick a direction, and get the equivalent in the other dialect — function names mapped through a 200-plus-pair dictionary, argument shapes restructured, separators normalized, ARRAYFORMULA added or removed as the destination requires. Untranslatable constructs are flagged honestly instead of being silently mangled. There is no signup, and the formula never leaves your tab.

A formula translation is not a find-and-replace, though find-and-replace is the tool most people attempt first. The real work happens in three layers, and the translator handles each explicitly. Layer one is names: the function dictionary mapping every renamed or regionally renamed function to its counterpart. Layer two is shape: argument order and arity differences, where the same function name means slightly different things on each side. Layer three is semantics: array evaluation, spilling, and the wrapper conventions that make range-wide formulas behave.

The dictionary deserves its reputation as the boring hero. Most of the 200-plus pairs are locale mappings — the localized names that non-English Excel installations display, which break instantly when pasted anywhere expecting English. The rest are genuine cross-app renames: Sheets' SPLIT against Excel's TEXTSPLIT, Sheets' REGEX family against Excel's nothing-at-all, and the small set of functions that exist in both but grew apart. Layer two catches the ones that share a name and differ underneath — SORT's argument shape, FILTER's missing not-found argument in Sheets — and rewrites the call to mean the same thing in the destination.

Layer three is where translations fail silently when done by hand, which is why it gets the most engineering. Excel 365's dynamic arrays spill; Sheets wants ARRAYFORMULA; legacy Excel wanted Ctrl+Shift+Enter and a prayer. A formula like SUM(IF(range="West", amounts)) is legal in all three worlds but must be written three different ways to actually calculate. The translator knows the destination's convention and emits the correct form, including the wrapper, so the formula arrives working rather than arriving plausible.

1. 1

   Paste the source formula

   Include the leading = so the parser can read it as a formula rather than text. Locale variants — semicolon separators, localized names — paste as-is; the parser handles them without pre-cleaning.

2. 2

   Pick the direction

   Excel to Sheets, Sheets to Excel, or enable auto-detect, which reads the markers (ARRAYFORMULA, SPLIT, separator style) and proposes what it found. You confirm, it converts.

3. 3

   Review the annotation list

   Every change the translator made is listed — name mapped, argument reshaped, wrapper added — with anything untranslatable flagged in red and paired with its closest equivalent where one exists.

4. 4

   Copy the output

   The translated formula lands ready to paste. Cross-sheet references keep their sheet names; absolute references keep their dollar signs.

5. 5

   Spot-check against known values

   Paste next to the original and confirm both return the same number on the same data — the two-minute verification step that catches any semantic drift the annotation list can't express.

The full mapping table runs past two hundred pairs, but the working core — the names that actually cause cross-border failures — is compact enough to learn by browsing. Here are the pairs worth knowing from memory, because you will meet all of them within a month of any hybrid workflow.

A pattern hiding in that table: the failures cluster where the two apps made genuinely different product decisions, and the successes cluster where one side simply named something first. TEXTSPLIT versus SPLIT is a naming accident from two decades apart. FILTER's missing fallback argument is a design disagreement about what should happen when a filter comes back empty — Excel returns your fallback text, Sheets returns #N/A and expects you to catch it. The translator's job is to know which category each pair falls into, because naming accidents convert cleanly and design disagreements convert only with a structural change wrapped around them.

The deepest dialect difference is invisible in single-cell formulas and unavoidable the moment a formula ranges. In Google Sheets, a formula like =IF(A2:A10="West", E2:E10, 0) needs ARRAYFORMULA around it to evaluate cell by cell across the ranges; without the wrapper it processes only the first cell and labels the rest with a silent padding of the result. Modern Excel does the equivalent automatically — the formula spills its results into neighboring cells with no ceremony at all. Excel before 2021 demanded Ctrl+Shift+Enter, marking the formula as an array formula in the UI.

So the same computation has three correct spellings depending on where it lives, and the translator selects the right one from the destination dropdown. Excel-to-Sheets wraps; Sheets-to-Excel unwraps. The subtle case is legacy Excel as the destination: the unwrapped formula is correct but inert until the user commits it with Ctrl+Shift+Enter, so the annotation list says so explicitly rather than letting someone conclude the tool failed. Migration notes that state their own caveats are the difference between a converter and a colleague.

-- Excel 365 (auto-spills):
=SUM(IF(A2:A100="West", E2:E100))

-- Google Sheets (same computation, explicit wrapper):
=ARRAYFORMULA(SUM(IF(A2:A100="West", E2:E100)))

-- Legacy Excel (same formula, entered with Ctrl+Shift+Enter):
{=SUM(IF(A2:A100="West", E2:E100))}

-- Identical result in all three: the sum of column E where column A is West.

The translator's output is verifiable in the classic way: run both versions on the same data and demand the same number. Below are four conversions with their inputs and outputs, including one that flags honestly instead of pretending.

That last case is the design line we drew on purpose. The valuable behavior when translation is impossible is a loud, specific, actionable refusal — which function, why, what the options are. Every silent approximation we tested became someone's broken quarter-end model, and no amount of successful conversions pays that back.

• Sheets-only live connectors. IMPORTRANGE, QUERY, GOOGLEFINANCE, GOOGLETRANSLATE pull live external data with no Excel function counterpart. The work needs restructuring on arrival — Power Query for QUERY-shaped jobs, linked workbooks or consolidation for IMPORTRANGE-shaped ones.
• Volatility and recalculation timing. NOW() and RAND() recalculate on different triggers in each app, so a workbook that self-refreshes acceptably in one can churn in the other. The formula translates; the behavior doesn't promise to match.
• Legacy date seams. Excel's 1900 leap-year bug (the phantom February 29, 1900) is absent in Sheets, so pre-March-1900 serials disagree between platforms. Everything from March 1900 forward aligns exactly — which is every real business date and, mercifully, almost nobody's problem.
• Number and date display. A formula can translate perfectly and still show dollars as euros, because formatting follows the destination sheet's locale, not the formula. Set File → Settings → Locale in Sheets (and Excel's regional options) as part of every migration, not as an afterthought.
• Text function edge behavior. TRIM collapses repeated internal spaces in Excel but only trims leading and trailing spaces in Sheets — so a data-cleaning chain can produce different strings from identical inputs. Verify TRIM-heavy pipelines on a sample before trusting either direction.
• Chart and conditional-format dependencies. A translated formula feeding a chart series works; the chart itself does not travel with the formula. Migration checklists live outside this tool's scope, and pretending otherwise would be a disservice.
• Scale of recalculation. Array-heavy models that spill thousands of cells recalculate at different speeds in each engine. Translation preserves correctness, not performance — profile the destination workbook after any large migration.

The account manager is the archetype: client on Sheets, internal model in Excel, a pricing formula crossing the border every time terms change. The translator turns a forty-minute, error-prone hand conversion into a paste-and-check. Close behind: the consultant who delivers to whichever app the client uses this quarter, the analyst consolidating subsidiary workbooks that arrived in mixed dialects, and the ops person whose Monday ritual is porting a vendor's Sheets tracker into the company's Excel system.

Then there's the migration crowd — teams moving an entire workbook fleet from one platform to the other, for cost or collaboration or an acquisition. Their unit of work is hundreds of formulas, and their bottleneck was never the mechanical conversions but the judgment calls; automating the mechanical part leaves the humans the part humans are for. A surprising fourth group is learners: people teaching themselves the second dialect by diffing translated formulas — genuinely one of the faster ways to internalize where the apps genuinely differ, because the delta is the lesson.

And a quiet fifth: anyone who has ever received a European colleague's spreadsheet. The semicolons and localized names parse fine in their home locale and fail instantly in yours; the locale-normalization mode exists for the moment of reception, before any cross-app translation is even involved.

The manual alternative deserves a fair comparison, because for a single simple formula, hand conversion is fine and always will be. The decision changes as volume and stakes grow.

The pattern is the usual one: automation earns nothing on the trivial case and everything on the repeated, high-stakes, or detail-dense cases. What tips most people permanently into the translator column is the annotation list — not the speed. Knowing precisely which three changes were made is what makes the paste trustworthy, and that knowledge is exactly what hand conversion never produces and documentation-diving produces only slowly. For formulas whose logic needs understanding rather than converting, run them through the Excel Formula Explainer first, then translate.

The translator takes a formula, not a workbook. That distinction carries the whole privacy argument: your data never enters the picture, only the logic that operates on it, and even that stays in the tab. The dictionary and the conversion engine are static assets loaded with the page; the conversion itself is local JavaScript; nothing about your formula — its function mix, its sheet names, its structure — is transmitted, logged, or retained. Close the tab and the translator forgets you entirely.

It also runs offline once loaded, which is a niche feature for a formula tool but a genuine one: the air-gapped finance machine, the long flight with a migration deadline, the plant network with a whitelist. Logic translation is exactly the kind of work that should not require connectivity, and here it doesn't.

Translation is one stop in a formula's life. Excel Formula Explainer dissects anything you inherit before you port it; Excel Formula Formatter prints the migrated formulas in review-ready shape for documentation; and when the translated result needs to land in a README or spec instead of a spreadsheet, Excel to Markdown Table Converter finishes the journey. Builders for the individual functions — the IF Formula Builder among them — sit one cluster over for formulas being written rather than moved.