Tool Builder is a way to add that interface without leaving Excel. You ask an AI tool to generate a small single-file web app, paste it into Tool Builder, and run it directly in the workbook. The workbook stays the source of truth. The app becomes the simpler surface around it.

That makes Tool Builder useful when the problem is not "how do I calculate this?" but "how do I make this workflow easier to use?"

Why people use it​

Tool Builder is a good fit when:

• the data already lives in a workbook
• people repeat the same review or update process every week
• the raw sheet is harder to use than the underlying task
• you want something faster than a custom internal app project
• you want the finished tool to travel with the workbook

That last part is important. Tool Builder stores the app inside the workbook itself, so the file carries the interface with it. You are not deploying a separate server, database, or app-specific sign-in flow just to make a spreadsheet easier to work with.

The workflow is simple​

Tool Builder works best as a short loop:

1. Start with a workbook problem.
2. Click Copy Guide in Tool Builder.
3. Paste the guide into a fresh chat with ChatGPT, Claude, Copilot, or another AI assistant.
4. Ask for a single-file HTML and JavaScript app for your workflow.
5. Paste the generated code into Tool Builder and run it in Excel.
6. Test it against real rows, then refine the prompt or the code.

If you want to see the pattern before writing your own prompt, Tool Builder also lets you load an example tool first.

What makes a good first app​

The best Tool Builder apps are small and specific. They feel more like focused work surfaces than general-purpose dashboards.

Strong starting points include:

• an expense or budget tracker
• a project tracker or Kanban-style board
• a guided data-entry form
• an inventory or reorder screen
• a review queue that surfaces exceptions first
• a KPI dashboard built from workbook tables

Some apps work on top of tables you already have. Others create their own workbook tables the first time they run. Both models are supported, which is why Tool Builder can work for both tracking workflows and reporting views.

If you want inspiration, the Tool Builder for Excel guide shows the product workflow, and the visualization catalog is a useful place to borrow dashboard and chart ideas.

Background of Regular Expressions​

Regular expressions (often abbreviated as regex or regexp) represent a highly specialized and powerful language for defining complex search patterns within text data. They are indispensable tools across various domains for tasks such as data validation, parsing semi-structured information, cleaning messy text, and extracting specific data points. Their ability to identify, match, and manipulate text based on intricate, predefined patterns significantly enhances efficiency and precision in data processing workflows. From validating email addresses and phone numbers to parsing log files or extracting specific keywords from documents, regex provides a flexible and robust mechanism for text manipulation.

For many years, users of Microsoft Excel, a ubiquitous tool for data management, faced significant limitations in performing advanced text manipulation directly within their spreadsheets. Achieving regex-like capabilities often required cumbersome combinations of basic text functions like LEN, FIND, REPLACE, SUBSTITUTE, LEFT, RIGHT, and MID. For more complex scenarios, users typically had to resort to writing Visual Basic for Applications (VBA) macros, which necessitated enabling specific references like "Microsoft VBScript Regular Expressions 5.5," or acquiring third-party add-ins. This presented a considerable barrier for many users seeking to perform sophisticated text processing directly within their familiar spreadsheet environment.

However, a pivotal shift has recently occurred with the introduction of three brand-new native regex functions in Excel: REGEXTEST, REGEXREPLACE, and REGEXEXTRACT. These functions fundamentally change the landscape by bringing powerful pattern matching directly into the Excel formula bar. This enhancement represents a strategic move by Microsoft to significantly bolster Excel's core data processing capabilities. It is not merely an incremental update but a fundamental re-tooling that empowers Excel to handle complex text patterns natively, reducing the reliance on external workarounds and positioning Excel as a more self-sufficient data manipulation platform. The anticipation of future integration into XLOOKUP and XMATCH further underscores this deeper embedding of regex power into Excel's lookup and matching functionalities.

In stark contrast to Excel's recent adoption, Python's re module has long been a cornerstone of text processing in the programming world. As a built-in library, it has provided a comprehensive and highly flexible interface for regular expressions for years. It is widely utilized in diverse applications such as data validation, web scraping, log analysis, and complex string manipulations, making Python a go-to language for advanced text processing and automation.

This report aims to provide a granular comparison between Excel's new native regex functions and Python's established re module. By dissecting their respective capabilities, underlying regex engines, supported syntax, and advanced features, this analysis will highlight key distinctions and areas of overlap. The objective is to empower advanced data professionals and developers to make informed decisions on which tool is best suited for specific text manipulation tasks, considering factors like complexity, scalability, and integration into existing workflows.

Excel's New Native Regex Functions: Capabilities and Syntax​

Excel's recent foray into native regular expression support is encapsulated in three distinct functions: REGEXTEST, REGEXEXTRACT, and REGEXREPLACE. These functions are designed to simplify and enhance complex text operations directly within Excel worksheets, offering a flexible and versatile alternative to combining numerous traditional text functions or resorting to VBA code. Their introduction eliminates the need for external add-ins for many advanced text manipulation scenarios, streamlining workflows for Excel users.

Detailed Syntax and Argument Descriptions for Each Function​

Each of the new Excel regex functions follows a clear syntax, incorporating optional arguments for common modifications like case sensitivity and specific match occurrences.

• REGEXTEST(text, pattern, [case_sensitivity]): This function evaluates whether any part of the provided text string contains a match for the specified pattern. It returns TRUE if a match is found and FALSE otherwise, making it ideal for data validation or quick pattern checks.
  • text (required): The cell reference or range containing the text string(s) to be checked.
  • pattern (required): The regular expression to match, which must be enclosed in quotation marks.
  • [case_sensitivity] (optional): This argument determines if the match is case-sensitive. A value of 0 (the default) specifies a case-sensitive match, while 1 specifies a case-insensitive match.
  • Example: =REGEXTEST(A1,"[0-9]") will return TRUE if cell A1 contains any numeric digit. Similarly, =REGEXTEST(A3:A12,"[a-zA-Z]") can be used across a range to identify cells containing alphabetic characters.
• REGEXEXTRACT(text, pattern, [return_mode], [case_sensitivity]): This function is designed to extract one or more parts of the supplied text that precisely match the defined pattern. It is invaluable for parsing messy data and pulling out specific pieces of information.
  • text (required): The cell reference or range containing the text string(s) from which to extract.
  • pattern (required): The regular expression that describes the specific text pattern to be extracted.
  • [return_mode] (optional): This argument specifies what should be extracted. A value of 0 (the default) returns only the first match found. 1 returns all non-overlapping matches. 2 returns the capture groups of the first match as separate parts, which is particularly useful for structured data extraction.
  • [case_sensitivity] (optional): Same as for REGEXTEST.
  • Example: =REGEXEXTRACT(B5,"\\d+") extracts the first sequence of one or more digits from cell B5. For extracting all initial-capped words, a formula like =REGEXEXTRACT(A2,"[A-Z][a-z]+",1) can be used, returning an array of matches.
• REGEXREPLACE(text, pattern, replacement, [occurrence], [case_sensitivity]): This function allows for the replacement of parts of a text string that match a regex pattern with a specified replacement string. It offers a significantly more powerful and flexible alternative to Excel's traditional SUBSTITUTE function for data cleaning and reformatting.
  • text (required): The cell reference or range containing the text string(s) within which replacements are to be made.
  • pattern (required): The regular expression that describes the text pattern to be replaced.
  • replacement (required): The text string that will replace the matched pattern instances.
  • [occurrence] (optional): This argument determines which instance of the pattern should be replaced. A value of 0 (the default) replaces all occurrences. A positive integer n replaces the nth occurrence from the start, while a negative integer -n replaces the nth occurrence searching from the end.
  • [case_sensitivity] (optional): Same as for REGEXTEST.
  • Example: =REGEXREPLACE(B5,"[^0-9]","") can be used to remove all non-numeric characters from telephone numbers in a column. A more advanced use involves reordering text, such as =REGEXREPLACE(A2,"([A-Z][a-z]+)([A-Z][a-z]+)","$2, $1") to swap and reformat "FirstNameLastName" into "LastName, FirstName" using capturing groups.

Overview of Supported Basic Regex Patterns, Metacharacters, and Quantifiers​

Excel's new functions support a robust set of common regex constructs, enabling versatile pattern matching:

• Literal Text: Matches the exact sequence of characters (e.g., 'abc' matches 'abc').
• Wildcard: The dot (.) matches any single character, with the exception of a newline character.
• Character Classes (Shorthands):
  • \\d: Matches any digit (0-9).
  • \\w: Matches any word character (letters, digits, or underscore).
  • \\s: Matches any whitespace character (space, tab, newline).
  • Their negated counterparts (\\D, \\W, \\S) are also supported.
• Custom Character Sets:
  • [abc]: Matches any one character listed within the brackets (e.g., gr[ae]y matches 'gray' or 'grey').
  • [a-z]: Matches any one character within the specified range (e.g., [a-z] matches any lowercase letter).
• Quantifiers: These specify the number of occurrences of the preceding element:
  • a\*: Matches zero or more occurrences of 'a'.
  • a+: Matches one or more occurrences of 'a'.
  • a?: Matches zero or one occurrence of 'a' (making it optional).
  • a{n}: Matches exactly n occurrences of 'a'.
  • a{n,m}: Matches between n and m occurrences of 'a'.
  • a{n,}: Matches n or more occurrences of 'a'.
• Word Boundary: \\b matches a position that is a word boundary (e.g., \\bcat\\b matches 'cat' in 'the cat sits' but not 'category').
• Alternation: a|b matches either 'a' or 'b' (e.g., cat|dog matches 'cat' or 'dog').
• Grouping: Parentheses () are used to group parts of the regular expression. This allows applying quantifiers to a group or capturing the matched subexpression. Non-capturing groups (?:...) can be used when grouping is needed but the matched content doesn't need to be captured.

Handling of Case Sensitivity and String Anchors (^, $)​

Case sensitivity is a configurable option for all three Excel regex functions. By default, matches are case-sensitive. However, users can easily disable this by setting the case_sensitivity argument to 1. This provides direct control over how character matching is performed.

The ^ (caret) and $(dollar sign) are crucial anchors in regex. In Excel's implementation, ^ matches the start of the entire string (cell content), and$ matches the end of the entire string. It is important to note that these anchors specifically match the beginning and end of the complete cell content, and not individual lines within a multi-line cell. For example, ^The will match "The cat" but not "In The", and .com$ will match "example.com".

Usage of Capturing Groups and Backreferences ($n)​

Capturing groups, defined by parentheses (), are fundamental for extracting specific portions of a match or for reordering text during replacement operations. When REGEXEXTRACT is used with return_mode=2, it can return separate parts of a single match individually, corresponding to the captured groups.

In the context of REGEXREPLACE, backreferences allow the content matched by a capturing group to be reinserted into the replacement string. This is achieved using $n, where n corresponds to the numerical order of the capturing group. For instance, $1 refers to the content of the first capturing group, $2 to the second, and so on. This capability is instrumental for tasks like reordering names (e.g., "First Last" to "Last, First") or restructuring data formats.

Underlying Regex Engine: PCRE2 Flavor​

A critical technical detail underpinning Excel's new regex capabilities is its choice of the PCRE2 ('Perl Compatible Regular Expressions 2') flavor for all three functions. PCRE2 is a robust, highly-featured, and widely adopted open-source regex engine. It is renowned for its close adherence to Perl 5 regex syntax and behavior, which is a de-facto standard in the regex world.

The adoption of PCRE2 brings several advantages: it supports comprehensive Unicode matching, allowing for accurate text processing across various languages and character sets. Furthermore, PCRE2 incorporates performance enhancements such as a Just-In-Time (JIT) compiler, which can significantly improve matching speed by compiling regular expressions into native machine code. It also features flexible memory management, utilizing the heap for backtracking information, which mitigates stack overflow issues that plagued older regex implementations. This strategic choice aligns Excel's regex capabilities with a powerful and familiar industry standard, making it easier for users already accustomed to Perl-compatible regex in other environments to transition and leverage a vast online knowledge base.

Table 1: Excel Regex Functions - Syntax and Core Parameters​

This table provides a concise, centralized reference for the fundamental structure and key arguments of each new Excel regex function. It serves as a practical guide for users to quickly grasp how to apply these functions for various text manipulation needs, directly addressing the "capabilities" aspect for Excel by summarizing its core usage.

Broader Implications of Excel's New Regex Capabilities​

Microsoft's decision to implement PCRE2 rather than extending its older VBScript regex engine or creating a proprietary one is a significant strategic choice. This move immediately grants Excel users access to a vast ecosystem of PCRE2-specific patterns, online testing tools, and community knowledge, thereby significantly lowering the learning curve for those familiar with Perl-compatible regex and enhancing interoperability with other systems that also use PCRE2. This positions Excel as a more robust data manipulation tool in a multi-platform environment, implying a commitment to providing powerful, modern text processing within Excel. This reduces the need for users to export data to other environments solely for complex regex tasks.

The direct integration of these powerful regex functions into Excel's cell-based formula environment is a fundamental shift. Previously, complex text operations often necessitated cumbersome nested traditional functions or the use of VBA macros, which could be intimidating for many users. Now, users can perform sophisticated text extraction, validation, and replacement interactively, seeing immediate results within the spreadsheet. The ability to define patterns in separate cells and reference them further enhances flexibility and reusability, making complex transformations more manageable and auditable. This significantly boosts productivity for common data cleaning and preparation tasks. It democratizes access to advanced text manipulation, enabling a broader base of Excel users to perform tasks that previously required specialized programming skills or external tools, thereby fostering greater self-sufficiency in data handling.

However, the power and flexibility of these new functions also introduce a notable, albeit unintended, consequence related to security. Recent analysis has demonstrated how REGEXEXTRACT can be leveraged for obfuscation of malicious code. By hiding PowerShell commands or other malicious components within large text strings in cells and using REGEXEXTRACT to dynamically reconstruct them at runtime, attackers can create highly evasive payloads. This technique has shown a significant drop in detection rates by traditional security heuristics compared to plain-text or conventionally obfuscated samples. This highlights a new and sophisticated attack vector within Excel documents, requiring security vendors to adapt their detection mechanisms. For organizations, it means an increased need for vigilance and potentially updated security policies regarding macro-enabled Excel files, as the very features designed for productivity can be repurposed for evasion.

Python's re Module: Comprehensive Regex Powerhouse​

Python's re module stands as a cornerstone for text processing in the programming world, offering a comprehensive and highly flexible interface for working with regular expressions. As a built-in library, it is an essential tool for tasks ranging from data validation and web scraping to complex string manipulations and parsing large text files.

Core Functions: re.search(), re.findall(), re.sub(), re.match(), re.compile()​

The re module provides a versatile set of functions designed for various regex operations:

• re.search(pattern, string, flags=0): This function scans through the string to find the first location where the pattern produces a match. If a match is found anywhere in the string, it returns a match object; otherwise, it returns None. The match object provides detailed information about the match, including its starting and ending positions.
• re.findall(pattern, string, flags=0): This function is used to find all non-overlapping occurrences of the pattern in the string. It returns a list of all matches. If the pattern contains capturing groups, it returns a list of tuples, where each tuple contains the captured groups for each match.
• re.sub(pattern, repl, string, count=0, flags=0): This function performs a substitution operation, replacing occurrences of the pattern in the string with the replacement string. The count argument can optionally limit the number of replacements performed. The repl argument can be a string (supporting backreferences) or even a function for more complex replacement logic.
• re.match(pattern, string, flags=0): Unlike re.search(), re.match() specifically checks if the pattern matches at the beginning of the string. It returns a match object if the pattern matches at the start, and None otherwise. This function is useful for validating strings that must conform to a pattern from their very first character.
• re.compile(pattern, flags=0): This function compiles a regular expression pattern into a regex object. Compiling patterns is a crucial performance optimization, especially when the same pattern is used multiple times within a program. It pre-processes the pattern, saving time on subsequent match operations.

Extensive Support for Basic Regex Patterns, Special Sequences, and Quantifiers​

Python's re module supports a comprehensive set of metacharacters and quantifiers, largely consistent with Perl-style regular expressions.

• Standard Metacharacters: Includes . (any character except newline), ^ (start of string/line), $ (end of string/line), \* (zero or more), + (one or more), ? (zero or one), | (OR), [] (character set), () (grouping).
• Special Sequences (Shorthands): \\d (any digit), \\D (any non-digit), \\w (any word character), \\W (any non-word character), \\s (any whitespace character), \\S (any non-whitespace character), \\b (word boundary), \\B (non-word boundary), \\n (newline).
• Quantifiers: Python supports fixed {n}, range {n,m}, and open-ended {n,} quantifiers, in addition to \*, +, ?.
• Greedy vs. Non-Greedy: By default, all quantifiers in Python are "greedy," meaning they attempt to match the longest possible string that satisfies the pattern. This behavior can be modified to "non-greedy" (or "minimal") by appending a ? to the quantifier (e.g., \*?, +?, ??). This is a critical control mechanism for precise parsing, particularly when dealing with nested structures or multiple potential matches. Understanding this distinction is vital for writing accurate and efficient regular expressions.

The Significance of Python's Raw String Notation (r"")​

A key best practice when defining regular expression patterns in Python is the use of raw string notation (e.g., r"pattern"). This addresses a common conflict: both Python's string literals and regular expressions use the backslash () as an escape character. For instance, \n in a standard Python string denotes a newline, but in regex, \n might match a literal newline character, or \d might denote a digit. If not using raw strings, to match a literal backslash in a regex, one might have to write \\\\ in a Python string literal, which can quickly become cumbersome and error-prone.

Raw strings (r"...") ensure that Python does not interpret backslashes as escape sequences within the string literal itself. This means the regex engine receives the pattern exactly as written, simplifying pattern creation and significantly reducing the potential for unexpected behavior or errors related to backslash interpretation.

Advanced Features: Lookahead and Lookbehind Assertions​

Python's re module provides full support for zero-width assertions, which are powerful constructs that allow matching a position in the string based on what follows or precedes it, without actually consuming any characters. This means they assert a condition without becoming part of the overall match.

• Lookahead Assertions:

  • (?=...) (Positive Lookahead): This assertion succeeds if the regular expression inside it (...) matches immediately after the current position in the string. For example, q(?=u) matches a 'q' only if it is immediately followed by a 'u', but the 'u' itself is not included in the match.
  • (?!) (Negative Lookahead): This assertion succeeds if the contained expression does not match immediately after the current position. For example, .*[.](./?!bat$)[^.]*$ can be used to match filenames that do not end with .bat.

• Lookbehind Assertions:

  • (?<=...) (Positive Lookbehind): This assertion succeeds if the regular expression inside it matches immediately before the current position in the string. For example, (?<=@)example matches 'example' only if it is preceded by '@'.
  • (?<!...) (Negative Lookbehind): This assertion succeeds if the contained expression does not match immediately before the current position. For example, (?<!a)b matches a 'b' that is not preceded by an 'a'.

  While many regex flavors impose fixed-width limitations on lookbehind patterns (requiring the engine to know how many characters to step back), Python's re module (being PCRE-like) is more flexible and can handle variable-width lookbehinds for finite repetitions.

Advanced Features: Named Capturing Groups​

Python's re module significantly enhances the readability and maintainability of complex regular expressions through the support of named capturing groups. Instead of relying solely on numerical indices, developers can assign descriptive names to captured substrings using the (?P<name>...) syntax.

• Syntax and Retrieval: For instance, (?P<first>\w+) (?P<last>\w+) captures a first name and last name. Matches can then be retrieved from a match object using either their numerical index (match.group(1)) or their assigned name (match.group('first')). The match.groupdict() method conveniently returns all named groups as a dictionary, making it easy to access and process structured data.
• Backreferencing: Named groups can also be backreferenced within the regex pattern itself using (?P=name). This is particularly useful for finding repeated patterns, such as \b(?P<word>\w+)\s+(?P=word)\b to identify doubled words like "the the".
• Replacement Strings: In replacement strings used with re.sub(), named groups are referenced using \g<name> (e.g., \g<first>) or \g<number> (e.g., \g<1>). This syntax helps avoid ambiguity, especially when group numbers might conflict with literal digits in the replacement string (e.g., \g<2>0 unambiguously refers to group 2 followed by '0', whereas \20 might be interpreted as group 20).

Advanced Features: Compilation Flags for Fine-Grained Control​

Python's re module offers a rich set of compilation flags that provide granular control over how regular expressions behave during matching. These flags can be passed as an argument to functions like re.search(), re.findall(), re.sub(), re.match(), or re.compile(). Multiple flags can be combined using the bitwise OR operator (|).

• re.IGNORECASE (re.I): Performs case-insensitive matching, meaning 'a' will match 'A' and vice-versa.
• re.DOTALL (re.S): Modifies the behavior of the . metacharacter to match any character, including newline characters. Without this flag, . matches everything except newlines.
• re.MULTILINE (re.M): Affects the behavior of the ^ and $ anchors. When set, ^ matches not only the start of the string but also the start of each line within the string (immediately following a newline). Similarly, $ matches the end of the string and the end of each line (immediately preceding a newline).
• re.VERBOSE (re.X): This flag allows for more readable regular expressions. It ignores whitespace within the pattern (unless escaped or within a character class) and enables comments (starting with # to the next newline). This is invaluable for breaking down long, complex patterns into manageable, documented sections, significantly aiding in debugging and maintenance.
• re.ASCII (re.A): When used with Unicode patterns, this flag makes special sequences like \\w, \\b, \\s, and \\d match only ASCII characters, overriding their default Unicode behavior.
• re.LOCALE (re.L): Makes \\w, \\W, \\b, \\B, and case-insensitive matching dependent on the current locale. While available, its use is generally discouraged in Python 3 due to the unreliability of the locale mechanism and better Unicode support by default.

Robust Unicode Support and Performance Considerations​

Python 3's re module offers robust Unicode support by default for string patterns, ensuring that regex operations correctly handle a wide range of international characters, including those beyond the basic ASCII set.

For performance optimization, especially when the same regex pattern is used repeatedly (e.g., in a loop processing many strings), compiling the pattern into a regex object using re.compile() is highly recommended. This pre-processing step saves time by avoiding repeated parsing of the pattern, leading to significant efficiency gains for frequently executed regex operations.

It is important to note that complex regular expressions, particularly those involving extensive backtracking or deep nesting of repetitions, can sometimes lead to a RuntimeError indicating that the "maximum recursion limit exceeded." This is a performance limitation related to the underlying matching engine's recursive nature. However, Python's re module provides a common strategy to mitigate this: restructuring the regex to use non-greedy quantifiers (e.g., *? instead of *) can often avoid deep recursion and, as a beneficial side effect, improve matching performance.

Table 2: Python re Module - Key Functions and Their Purpose​

This table provides a concise overview of the most commonly used functions within Python's re module. It helps users quickly understand its core capabilities and how they map to different text processing needs, such as searching for patterns, extracting all matches, performing replacements, or checking for matches at the beginning of a string. This directly addresses the "capabilities" aspect of the query for the re module.

Broader Implications of Python's re Module​

Python's re module, being an integral part of a full-fledged programming language, offers unparalleled programmatic control and scalability. This means regex operations can be seamlessly interwoven with other programming constructs like loops, conditional statements, file input/output, database interactions, and integration with vast data analysis libraries (e.g., Pandas). The explicit presence of re.compile() and mechanisms to handle recursion limits indicates a design philosophy geared towards efficiency and robustness for large-scale or iterative tasks. Python is inherently superior for automation, batch processing, building complex text analysis pipelines, and handling massive datasets where interactive, cell-based formulas in Excel would become impractical, unwieldy, or computationally inefficient. Its environment allows for sophisticated error handling and logging, which are critical for production systems.

Furthermore, features like named capturing groups and the re.VERBOSE flag are powerful tools for managing the complexity of advanced regular expressions. Named groups provide semantic meaning to captured substrings, making complex patterns self-documenting and easier to understand, especially in collaborative development. The re.VERBOSE flag allows developers to format long, intricate regex patterns across multiple lines with comments, significantly improving their readability, debuggability, and long-term maintainability—qualities often challenging to achieve with single-line Excel formulas. For projects involving highly complex or frequently evolving regex patterns, Python's re module offers superior tools for pattern design, documentation, and collaborative development, ultimately reducing development time and the likelihood of errors.

Finally, Python's comprehensive set of compilation flags provides developers with an exceptional degree of control over how the regex engine interprets patterns and the text being searched. This allows for precise tailoring of matching behavior to specific, often nuanced, requirements—such as handling case sensitivity, matching across newline characters, or defining character sets based on specific ASCII or Unicode properties. This level of explicit control is not directly exposed as arguments in Excel's new functions. This detailed control makes Python's re module more adaptable to a wider array of diverse and challenging text matching scenarios, particularly when dealing with internationalized text, highly specific data formats, or situations where default regex behaviors are insufficient.

Direct Comparison: Feature Parity and Key Distinctions​

While both Excel's new native functions and Python's re module provide powerful regex capabilities, their underlying design philosophies, exposed features, and optimal use cases present significant distinctions.

Functional Equivalence: Mapping Excel's Functions to Python's re Module Operations​

At a high level, Excel's new regex functions have direct functional counterparts in Python's re module:

• REGEXTEST (Excel) is functionally equivalent to performing a re.search() or re.match() operation in Python and then checking if a match object was returned (i.e., if re.search(pattern, string):).
• REGEXEXTRACT (Excel) aligns with Python's re.findall() when extracting all matches. For extracting the first match or specific capturing groups, it maps to re.search() followed by accessing match.group() or match.groups().
• REGEXREPLACE (Excel) directly corresponds to Python's re.sub() function, both designed for pattern-based text substitution.

Regex Flavor Comparison: PCRE2 (Excel) vs. Python's re Engine​

Excel's new functions explicitly utilize the PCRE2 regex flavor. PCRE2 is highly compatible with Perl 5 regex syntax and is known for its extensive features, including robust Unicode support and performance optimizations like JIT compilation. Python's re module implements its own regex engine, which is also highly capable and broadly compatible with PCRE/Perl-style regex. While both are powerful and share a common heritage, subtle differences in their default behaviors and the extent to which advanced features are exposed or implemented can exist.

Supported Regex Constructs: A Side-by-Side Analysis​

Both Excel (PCRE2) and Python's re module support the vast majority of standard regex metacharacters, character classes, and quantifiers. This includes common elements like . (any character), * (0 or more), + (1 or more), ? (0 or 1), | (OR), [] (character set), () (grouping).

A notable difference in syntax involves escaping. Both environments require backslashes () to escape special characters to match them literally (e.g., \. to match a literal dot). However, Python strongly recommends the use of raw string notation (r"") for regex patterns to prevent Python's own string literal escape interpretation, a consideration not present in Excel's formula environment.

Advanced Feature Discrepancies​

Despite their shared regex lineage, there are key differences in the support and exposure of advanced regex features:

• Lookarounds:
  • Excel (PCRE2): Excel's documentation explicitly mentions the ability to "look ahead" to match patterns only when they occur before something else, implying support for positive lookahead (?=...) and negative lookahead (?!...). However, the provided documentation for Excel's new functions does not explicitly confirm native support for lookbehind assertions ((?<=...), (?<!...)). While PCRE2 itself supports lookbehind, and even handles variable-width lookbehinds for finite repetitions, its exposure in Excel's formula interface is not clearly stated. This is a point of potential limitation or unconfirmed feature for the new native functions, especially considering older VBA regex explicitly lacked lookbehind support.
  • Python re: Python's re module fully supports both positive/negative lookahead and lookbehind assertions. Its engine is notably flexible regarding variable-width patterns within lookbehinds, offering robust capabilities for complex conditional matching.
• Named Capturing Groups:
  • Excel (PCRE2): The provided documentation for Excel's new functions (specifically REGEXREPLACE) only illustrates and mentions support for numbered capturing groups ($n). There is no explicit mention or example of named capturing groups ((?P<name>...) or \k<name>). This aligns with the fact that older VBA regex explicitly lacked named groups.
  • Python re: Python's re module explicitly supports named capturing groups ((?P<name>...)). These can be referenced by name (e.g., match.group('name'), \g<name>) or by numerical index, significantly improving the readability and maintainability of complex patterns.
• Flags and Options:
  • Excel (PCRE2): Excel's new functions offer limited direct control over matching behavior via function arguments, primarily case_sensitivity (0 or 1). While the underlying PCRE2 engine boasts a wide array of flags for fine-grained control (e.g., DOTALL, MULTILINE, EXTENDED, CASELESS), Excel's formula interface does not directly expose these as arguments.
  • Python re: Python's re module provides extensive control through a rich set of compilation flags (e.g., re.IGNORECASE, re.DOTALL, re.MULTILINE, re.VERBOSE), which can be combined using the bitwise OR operator (|). This allows for highly customized and precise matching behavior.
• Atomic Grouping & Possessive Quantifiers:
  • Excel (PCRE2): PCRE2 generally supports atomic groups ((?>...)) and possessive quantifiers (*+, ++, ?+, {m,n}+), which prevent backtracking and can optimize performance for certain patterns. However, Excel's documentation does not explicitly confirm their support or usage within the native functions. Older VBA regex explicitly lacked these features.
  • Python re: Python's re module does not natively support atomic grouping or possessive quantifiers. Python's primary mechanisms for controlling matching behavior are its default greedy quantifiers with backtracking and the explicit use of non-greedy quantifiers (*?).
• Multiline Anchors (^ and $):
  • Excel (PCRE2): In Excel, the ^ and $ anchors consistently match the start and end of the entire cell string, respectively. They do not match the start or end of individual lines within a multi-line cell.
  • Python re: By default, ^ and $ in Python's re module match the start and end of the string. However, when the re.MULTILINE (re.M) flag is set, their behavior changes to match the start and end of each line within the string. This difference in default behavior and optional control is significant for multi-line text processing.
• Unicode Support:
  • Excel (PCRE2): PCRE2 offers robust Unicode support. This means that character classes like \d, \w, and \s typically handle a wider range of international characters beyond just ASCII digits/letters. The extent to which Excel's implementation fully leverages and exposes all PCRE2 Unicode character properties by default is not exhaustively detailed in the provided documentation, though PCRE2's PCRE2_UCP option enables full Unicode character properties.
  • Python re: Python 3's re module handles Unicode characters effectively by default for string patterns. The re.ASCII flag can be used to restrict \d, \w, \s to ASCII-only matching if specifically required.

Integration and Workflow​

• Excel: The new regex functions are formula-based, making them ideal for interactive data exploration, ad-hoc analysis, and scenarios where data remains within the spreadsheet environment. They are easy to apply across ranges of cells and integrate seamlessly into existing Excel workflows.
• Python: The re module is programmatic, making it ideal for automation, scripting, large-scale data processing (e.g., processing entire directories of text files), and integration with other systems or applications. It requires a development environment and programming knowledge.

Performance and Scalability​

• Excel: The underlying PCRE2 engine benefits from features like a JIT compiler and heap-based backtracking, which should provide good performance for in-cell operations. However, for extremely large datasets or highly complex patterns applied across vast numbers of cells, Excel's overall calculation engine might still impose practical limitations.
• Python: Python offers explicit performance optimizations such as re.compile() for repeated pattern usage and strategies to mitigate recursion limits (e.g., using non-greedy quantifiers). Its programmatic nature allows for optimized handling of large text files or streaming data, making it generally more scalable for high-volume or computationally intensive regex tasks.

Table 3: Feature Comparison: Excel Regex vs. Python re Module​

This table is central to the comparison, offering a side-by-side view of specific regex features and their support in each environment. It directly addresses the "differences" aspect of the query in a structured, easy-to-digest format, synthesizing information from various sources to highlight both parity and discrepancies.

Broader Implications of the Feature Comparison​

The comparison highlights a fundamental difference in the exposure of features, even when the underlying engine (PCRE2 for Excel) is highly capable. While Excel's new functions leverage the powerful PCRE2 engine, its user interface (via function arguments) only exposes a limited subset of PCRE2's full capabilities. For instance, only case_sensitivity is a direct argument, with no explicit flags for behaviors like DOTALL or MULTILINE directly exposed in the functions. In contrast, Python's re module explicitly exposes a wide array of flags, allowing developers to fine-tune regex behavior. This indicates that Excel prioritizes ease of use and common scenarios for a broader user base, whereas Python caters to developers needing granular control. For advanced regex patterns requiring specific matching behaviors (e.g., matching across newlines, complex Unicode property matching beyond basic \d/\w), Python will likely remain the more flexible and capable tool, even if the underlying Excel engine theoretically supports such features. Users might encounter a "feature ceiling" within Excel's formula interface for highly specialized regex needs.

The fundamental difference in interface—formula-based in Excel versus programmatic in Python—creates a direct link to optimal workflow. Excel's strength lies in interactive, iterative data exploration and transformation directly within the spreadsheet, making it suitable for ad-hoc analysis. Python's strength is in automation, batch processing, and integration with larger software systems, where repetitive tasks or massive datasets are involved. The lack of named groups and limited flag exposure in Excel makes complex regex patterns harder to manage and debug in a formula context compared to Python's scripting environment. This implies that users should choose their tool not just based on regex feature parity, but primarily on the nature of the task: interactive, spreadsheet-centric tasks for Excel; automated, large-scale, or system-integrated tasks for Python.

Furthermore, the differing default behaviors of anchors (^, $) for multiline matching can lead to subtle but significant errors if a user is accustomed to one environment and assumes identical behavior in the other. In Excel, ^ and$ always match the start and end of the entire cell string. In Python, they match the start and end of the string by default, but with the re.MULTILINE flag, they match the start and end of each line. Similarly, Python's explicit raw string notation is a crucial best practice that Excel users don't need to consider, but Python users must master to avoid unexpected backslash interpretations. This highlights that users transitioning between Excel and Python regex need to be acutely aware of these default behavior differences and explicit syntax requirements to avoid frustrating debugging sessions and ensure correct pattern matching.

Practical Applications and Recommendations​

Understanding the distinct capabilities and design philosophies of Excel's new regex functions and Python's re module is crucial for selecting the most appropriate tool for a given task. Neither tool is universally superior; rather, their strengths are complementary, aligning with different operational contexts and user profiles.

Excel's new native regex functions are particularly well-suited for scenarios that prioritize interactivity, immediate results, and operations within the familiar spreadsheet environment:

• Ad-hoc Data Cleaning and Validation: For quick, one-off tasks like removing unwanted characters (e.g., =REGEXREPLACE(B5,"[^0-9]","") to clean phone numbers), reformatting strings, or checking for the presence of specific patterns (e.g., =REGEXTEST(A1,"[0-9]")) within a single column or a small range of data.
• Interactive Data Extraction: When there's a need to pull out specific pieces of information (e.g., numbers, names, email parts) from semi-structured text directly in a cell, REGEXEXTRACT provides an immediate and visible solution. This is highly beneficial for data exploration.
• Collaborative Data Analysis: When working with colleagues who are comfortable with Excel but not programming, the formula-based approach allows for transparent, auditable text processing that can be easily reviewed and modified by non-programmers.
• Small-scale Transformations: For datasets that fit comfortably within Excel's row limitations and where the complexity doesn't exceed what can be reasonably managed in formula form.

Conversely, Python's re module is the superior choice for scenarios requiring programmatic control, advanced features, or operations that exceed Excel's practical limitations:

• Large-scale Data Processing: When working with massive datasets (millions of records), multiple files, or text files that exceed Excel's capacity. Python can process entire directories of log files, web scraping results, or database exports efficiently using loops and batch operations.
• Complex Pattern Requirements: For advanced regex features not exposed in Excel's function interface, such as named capturing groups ((?P<name>...)), lookbehind assertions of variable width, atomic grouping, or fine-grained control over matching behavior through multiple flags (re.DOTALL, re.VERBOSE, re.MULTILINE).
• Automated and Scheduled Tasks: When text processing needs to be part of automated pipelines, ETL processes, or scheduled scripts. Python excels at unattended operations, error handling, and integration with other systems (databases, APIs, file systems).
• Multi-step Text Processing Workflows: For complex text analysis requiring multiple regex operations, conditional logic, or integration with other Python libraries (pandas for data manipulation, requests for web scraping, json for API responses). Excel's formula-based approach becomes unwieldy for multi-step transformations.
• Performance-critical Applications: When processing speed is crucial, Python's re.compile() optimization for repeated pattern usage, combined with the ability to implement efficient algorithms and data structures, often outperforms Excel's calculation engine for intensive regex operations.
• Integration with Machine Learning and NLP: When regex is part of a larger text preprocessing pipeline for natural language processing, sentiment analysis, or machine learning models. Python's ecosystem (NLTK, spaCy, scikit-learn) seamlessly integrates with regex operations.
• Log File Analysis and System Monitoring: For parsing server logs, application logs, or system outputs where patterns may span multiple lines, require precise timing analysis, or need to be aggregated across thousands of files. Python's file handling and string processing capabilities far exceed what's practical in Excel.
• Web Scraping and API Data Processing: When extracting structured data from HTML, XML, JSON responses, or other semi-structured formats where regex is combined with HTTP requests, DOM parsing, or API authentication. Python's requests library and regex integration provide a powerful combination.
• Cross-platform and Deployment Scenarios: When the text processing solution needs to run on servers, cloud environments, or non-Windows systems where Excel may not be available. Python scripts are highly portable and can be deployed virtually anywhere.
• Version Control and Collaboration on Logic: When the regex patterns and processing logic need to be version-controlled, peer-reviewed, or maintained as part of a larger codebase. Python scripts integrate naturally with Git workflows and software development practices.

The decision between Excel and Python should ultimately be driven by the scope, complexity, and operational context of the task. Excel excels in interactive, exploratory scenarios with moderate complexity, while Python dominates in automated, large-scale, and feature-rich applications.

References​

1. Regular Expressions in Excel | Exceljet, accessed July 24, 2025, https://exceljet.net/articles/regular-expressions-in-excel
2. Excel RegEx examples: using regular expressions in formulas - Ablebits.com, accessed July 24, 2025, https://www.ablebits.com/office-addins-blog/excel-regex-formulas/
3. Excel(ent) Obfuscation: Regex Gone Rogue - Deep Instinct, accessed July 24, 2025, https://www.deepinstinct.com/blog/excellent-obfuscation-regex-gone-rogue
4. Mastering the Power of Regular Expressions with Python's 're' Module: A Comprehensive Guide with Examples | by Khaleel ur Rehman | Medium, accessed July 24, 2025, https://medium.com/@khaleel92/mastering-the-power-of-regular-expressions-with-pythons-re-module-a-comprehensive-guide-with-141b855ac403
5. Python Regular Expression (RegEX) - Simplilearn.com, accessed July 24, 2025, https://www.simplilearn.com/tutorials/python-tutorial/python-regular-expressions
6. Introducing the new REGEX function set in Excel, accessed July 24, 2025, https://globalexcelsummit.com/post/introducing-the-new-regex-function-set-in-excel
7. How to use Regular Expressions (Regex) in Microsoft Excel both in-cell and loops, accessed July 24, 2025, https://stackoverflow.com/questions/22542834/how-to-use-regular-expressions-regex-in-microsoft-excel-both-in-cell-and-loops
8. Excel gets Regular Expression functions - Office Watch, accessed July 24, 2025, https://office-watch.com/2025/huge-news-excel-gets-regular-expression-functions/
9. Regular Expression HOWTO — Python 3.13.5 documentation, accessed July 24, 2025, https://docs.python.org/3/howto/regex.html
10. REGEXTEST Function - Microsoft Support, accessed July 24, 2025, https://support.microsoft.com/en-us/office/regextest-function-7d38200b-5e5c-4196-b4e6-9bff73afbd31
11. REGEXEXTRACT Function - Microsoft Support, accessed July 24, 2025, https://support.microsoft.com/en-us/office/regexextract-function-4b96c140-9205-4b6e-9fbe-6aa9e783ff57
12. REGEXREPLACE Function - Microsoft Support, accessed July 24, 2025, https://support.microsoft.com/en-us/office/regexreplace-function-9c030bb2-5e47-4efc-bad5-4582d7100897
13. PCRE2 - Perl-Compatible Regular Expressions - GitHub Pages, accessed July 24, 2025, https://pcre2project.github.io/pcre2/
14. Perl Compatible Regular Expressions - Wikipedia, accessed July 24, 2025, https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions
15. 7.2. re — Regular expression operations — Jython v2.5.2 ..., accessed July 24, 2025, https://www.jython.org/jython-old-sites/docs/library/re.html
16. Lookahead and Lookbehind Tutorial—Tips &Tricks - RexEgg, accessed July 24, 2025, https://www.rexegg.com/regex-lookarounds.php
17. Regex Tutorial - Lookahead and Lookbehind Zero-Length Assertions, accessed July 24, 2025, https://www.regular-expressions.info/lookaround.html
18. Text.Regex.Pcre2 - Hackage, accessed July 24, 2025, https://hackage.haskell.org/package/pcre2/docs/Text-Regex-Pcre2.html

Why Use Python Statistical Functions in Excel?​

While Excel offers a range of built-in statistical functions, they are often limited in scope. Many distributions are missing, and even for supported distributions, Excel typically only provides basic PDF, CDF, or quantile calculations. In contrast, our Python functions offer:

• Full distribution support (PDF, CDF, inverse CDF, survival, inverse survival)
• Comprehensive statistics (mean, median, variance, standard deviation)
• Flexible parameterization (location and scale for all distributions)
• Access to distributions not available in Excel

Comparison Table: Python vs. Native Excel Functions​

Legend:

• PDF: Probability Density Function
• CDF: Cumulative Distribution Function
• Quantile: Inverse CDF
• Survival: Survival Function (1 - CDF)
• Stats: Mean, Median, Variance, Standard Deviation

Example: Using Python Functions in Excel​

Suppose you want to compute the inverse CDF (quantile) for the Weibull distribution, which is not available in native Excel. With the new Python function, you can simply use:

=WEIBULL_MIN(0.95, 1.5, 0, 1, "icdf")

Similarly, for distributions not available in Excel at all (like Pareto or Cauchy), you can now perform advanced statistical analysis directly in your spreadsheet.

Getting Started​

To use these functions, add them from the list of Example Functions in our Python for Excel add-in. Then, simply call the functions as you would any Excel formula.

You can see the full list of available functions in our Python Functions Repository.

Excel Statistical Functions​

Our goal is to provide a broad range of example functions that demonstrate how Python can extend Excel's capabilities, enabling users to perform complex calculations, data analysis, and automation tasks directly within their spreadsheets. These can be used to accelerate the building your own custom functions tailored to your specific business needs.

Please be aware that these functions are not rigorously tested, so they should not be used as-is for production purposes without further validation. They are provided purely as examples.

Why Use Python Functions in Excel?​

While Excel is a powerful tool for calculations and data analysis, it has limitations when it comes to advanced analytics, automation, and integration. Python functions allow you to:

• Perform advanced statistical analysis, optimization, and modeling using industry-standard libraries.
• Connect to APIs, web data, and external sources with just a formula.
• Analyze unstructured data, such as text, with natural language processing tools.
• Build custom solutions that scale beyond what is possible with built-in Excel features.

Request a Function​

If there is a function you'd like to see, please Contact us.

The integration of Artificial Intelligence (AI) directly into spreadsheet functions is changing this paradigm. Now, users can leverage the power of large language models (LLMs) and other AI techniques to perform tasks that were previously difficult or impossible within the confines of rows and columns. This document explores the diverse applications of AI in spreadsheets, transforming them from static data containers into dynamic tools for insight generation, automation, and enhanced productivity.

Discover how AI-powered functions like AI_ASK, AI_EXTRACT, AI_FORMAT, and others are revolutionizing spreadsheet workflows by enabling natural language interaction, intelligent data extraction, and automated pattern recognition. These capabilities transform spreadsheets into powerful tools for insight generation, data processing, and workflow automation across diverse business domains.

Core AI Capabilities in Spreadsheets​

Modern AI spreadsheet functions bring several core capabilities directly to your data:

1. Natural Language Understanding & Generation: Interacting with your data using plain English, generating text, answering questions, and summarizing content (AI_ASK).
2. Data Extraction & Structuring: Pulling specific pieces of information from unstructured text and organizing it into tables (AI_EXTRACT, AI_TABLE).
3. Data Cleaning & Formatting: Standardizing inconsistent data formats (dates, addresses, names) automatically (AI_FORMAT).
4. Pattern Recognition & Completion: Identifying complex patterns in data and filling in missing values or extending series based on examples (AI_FILL).
5. Classification & Categorization: Assigning labels or categories to data based on criteria or examples (e.g., sentiment analysis, topic modeling) (AI_CHOICE).
6. List Generation: Create lists based on prompts or existing data (AI_LIST).

Available AI Text Functions​

The following functions leverage AI to work with text data:

Let's delve into practical applications of these capabilities.

Application Examples​

Market Research & Customer Feedback Analysis​

AI functions can revolutionize how businesses analyze customer feedback, reviews, and survey responses.

Sentiment Analysis: Quickly gauge customer feelings from text.

• Input Data:

• AI Application (AI_CHOICE): =AI_CHOICE(B2, "Positive, Negative, Neutral")
• Output:

Topic Extraction: Identify key themes mentioned in feedback.

• Input Data: (Same as above)
• AI Application (AI_EXTRACT): =AI_EXTRACT(B2, "the main topic")
• Output:

Summarization: Condense long reviews or comments.

• Input Data:

• AI Application (AI_ASK): =AI_ASK("Summarize the following review in one sentence:", B2)
• Output:

Sales & Marketing Automation​

Streamline lead management, content creation, and outreach personalization.

Lead Qualification: Categorize leads based on descriptions or interactions.

• Input Data:

• AI Application (AI_CHOICE): =AI_CHOICE(B2, "Hot, Warm, Cold")
• Output:

Extracting Contact Information: Pull emails, phone numbers, or company names from text blocks.

• Input Data:

• AI Application (AI_EXTRACT): =AI_EXTRACT(A2, "the email address")
• Output:

Data Cleaning and Standardization​

AI can tackle messy data that traditional formulas struggle with.

Formatting Addresses: Standardize inconsistent address formats.

• Input Data:

• AI Application (AI_FORMAT): =AI_FORMAT(A2, "Standard US Address format: Street, City, ST ZIP")
• Output:

Cleaning Names: Correct capitalization and potentially identify parts of names.

• Input Data:

• AI Application (AI_FORMAT): =AI_FORMAT(A2, "Proper Name Capitalization")
• Output:

Content Creation & Brainstorming​

Leverage AI to generate ideas and draft content directly within your spreadsheet planning environment.

Generating Ideas: Brainstorm blog post titles, marketing slogans, or feature names.

• Input Data:

• AI Application (AI_LIST): =AI_LIST("Generate 5 blog post titles about "&A2)
• Output (Example for Row 1):

Creating Structured Data from Text: Turn meeting notes or descriptions into tables.

• Input Data:

• AI Application (AI_TABLE): =AI_TABLE(A2, "Action Item, Owner, Due Date")
• Output:

Pattern Recognition and Data Augmentation​

AI_FILL allows you to go beyond simple series filling (like 1, 2, 3...) to recognize complex relationships and fill data based on examples.

• Input Data & Goal: Fill in the 'Category' based on the 'Product SKU' pattern.

• AI Application (AI_FILL): Using example_range of the first 3 rows and fill_range of the remaining 3 rows with missing categories
• Output:

• Industry Inference Example: Use AI_FILL to infer the likely industry of a company based on its name and a few examples (e.g., provide examples like "Tech Innovations Inc." -> "Technology", "Global Logistics Co." -> "Logistics").

Combining AI Functions for Complex Workflows​

The true power emerges when combining these functions. Imagine analyzing product feedback:

1. Paste Raw Feedback: Place raw customer feedback text into Column A.
2. Extract Product Name (AI_EXTRACT): In Column B, use =AI_EXTRACT(A2, "the product name mentioned").
3. Analyze Sentiment (AI_CHOICE): In Column C, use =AI_CHOICE(A2, "Positive, Negative, Neutral").
4. Extract Key Topics (AI_LIST): In Column D, use =AI_LIST(A2, "List key topics or features mentioned").
5. Summarize Feedback (AI_ASK): In Column E, use =AI_ASK("Summarize the feedback in one sentence:", A2).

This creates a structured dashboard from unstructured text, ready for pivoting, filtering, and further analysis – all within the spreadsheet.

Tips for Effective Use​

• Be Specific with Prompts: The clearer your instruction (for AI_ASK, AI_FORMAT, AI_EXTRACT, etc.), the better the result. Instead of "fix this", try "Format as YYYY-MM-DD date".
• Provide Good Examples: For functions like AI_FILL or AI_CHOICE (when used with examples), ensure your examples accurately represent the desired output and cover different scenarios.
• Start Small: Test AI functions on a subset of your data first to understand their behavior and refine your prompts.
• Review Results: AI is powerful but not infallible. Always review the generated results for accuracy, especially for critical data.
• Understand Limitations: Be aware of potential biases in the AI models and any usage limits or costs associated with the functions.
• Consult Documentation: For detailed usage, parameters, and more examples, see the linked documentation for each function in the table above.

Conclusion​

Integrating AI into spreadsheets transforms them from passive calculators into active partners in data analysis and workflow automation. By leveraging natural language processing, pattern recognition, and data structuring capabilities, users can:

• Quickly extract insights from unstructured text.
• Automate tedious data cleaning and formatting tasks.
• Generate creative content and ideas efficiently.
• Build more sophisticated and automated workflows.

As AI technology continues to evolve, its applications within the familiar spreadsheet environment will only grow, further empowering users to unlock the value hidden within their data. This shift marks a significant evolution, making advanced data manipulation and insight generation accessible to a much broader audience.

Key Features​

Monaco Editor Integration​

The add-in now includes the same editor (Monaco) used in VS Code, providing:

• Syntax highlighting for Python
• Code completion and formatting
• Error detection

Function Management​

A new Functions tab lets you:

• View all Python functions in your workbook
• Edit existing functions
• Delete unused functions
• Import functions from Jupyter notebooks

Testing Integration​

Write test cases directly in your Python code:

def hello(first, last):
    """ Returns a greeting. """
    greeting = f"Hello {first, last}!"
    return greeting
    
# Test cases for the function
test_cases = [["Nancy", "Morgan"], ["Ming", "Lee"]]

# Excel usage: =HELLO("Nancy", "Morgan")

Click "Test" to run your cases and see results in the Output tab.

How It Works​

Creating a Python-powered LAMBDA function is now a two-step process:

1. Write your Python function in the editor
2. Click Save to create the LAMBDA

The Python code is stored in workbook settings and a corresponding LAMBDA function is automatically created in Excel's name manager. For example, this Python function:

def inches_to_mm(inches):
    """ Converts inches to millimeters. """
    return inches * 25.4

Creates this LAMBDA in Excel:

=LAMBDA(inches, BOARDFLARE.EXEC("workbook-settings:inches_to_mm", inches))

Jupyter Notebook Integration​

A particularly exciting feature is the ability to import functions from Jupyter notebooks. You can:

• Import from our example notebooks
• Load notebooks from GitHub Gists
• Use the notebooks as templates for your own functions

This makes it easy to maintain a library of functions in notebooks and import them into Excel as needed.

Try It Out​

To get started with the new code editor:

1. Install the Python for Excel add-in
2. Open the task pane and go to the Editor tab
3. Try writing a simple function or import one of our examples
4. Click Save to create your LAMBDA function

The code editor is available now in version 1.1.0 of the add-in. For more details, check out our updated documentation.

What's Next?​

We're continuing to improve the editor experience. Coming soon:

• Support for optional arguments
• More example notebooks
• Enhanced type conversion options

Let us know what features you'd like to see next!

Our text_distance function for fuzzy matching is similar to that used in our Fuzzy Match app, but supports many more algorithms and can be readily modified to your specific needs. Actually, we've recently updated our Fuzzy Match tutorial with more details.

NLTK Library​

The Natural Language Toolkit (NLTK) is a powerful library for natural language processing. It provides various tools and algorithms for text processing, including tokenization, stemming, lemmatization, and distance metrics. We will focus on using NLTK to calculate similarity scores between strings for fuzzy matching.

An example of calculating the similarity of two strings using edit_distance is shown below:

from nltk.metrics.distance import edit_distance

string1 = "apple"
string2 = "apples"
distance = edit_distance(string1, string2)
print(distance)

In this example, the edit_distance function calculates the minimum number of single-character edits required to change one string into the other. The output will be 1, indicating that the strings 'apple' and 'apples' have an edit distance of 1.

NLTK supports various distance metrics for calculating similarity between strings, including:

• Jaccard Distance: Measures the similarity between two sets by comparing the intersection and union of the sets.
• Levenshtein Distance: Calculates the minimum number of single-character edits required to change one word into the other.
• Jaro Similarity: Measures the similarity between two strings by considering the number of matching characters and transpositions.

Python Function​

We've created the nltk_distance function to handle the typical use-case in Excel of finding a match for a lookup_value in a lookup_array, similar to how the XMATCH function works. It normalizes the edit_distance results to a similarity score of 0-1 for easier comparison. The function is as follows:

import nltk
import pandas as pd
from nltk.metrics.distance import edit_distance, jaccard_distance, jaro_similarity
from nltk.util import ngrams

def nltk_distance(lookup_value, lookup_array_df, algorithm):
    """
    Calculate the similarity between a lookup_value and a lookup_array using various distance algorithms.

    Parameters:
    lookup_value (str or pd.DataFrame): The string or DataFrame to search for.
    lookup_array_df (pd.DataFrame): The DataFrame to search within.
    algorithm (str): The algorithm to use for calculating similarity. Options are 'levenshtein', 'jaccard', and 'jaro'. Default is 'jaccard'.

    Returns:
    list: A list of lists where each sublist contains the index (1-based) and the similarity score of the most similar item in the lookup_array.
    """
    # Define a dictionary to map algorithm names to functions
    algo_funcs = {
        'levenshtein': lambda x, y: 1 - edit_distance(x, y) / max(len(x), len(y)),
        'jaccard': lambda x, y: 1 - jaccard_distance(set(ngrams(x, 2)), set(ngrams(y, 2))),
        'jaro': jaro_similarity
    }
    
    # Get the algorithm function from the dictionary
    algo_func = algo_funcs.get(algorithm)
    if algo_func is None:
        raise ValueError(f"Unsupported algorithm: {algorithm}")
    
    # Flatten the DataFrame to a list
    lookup_array = lookup_array_df.values.flatten().tolist()
    
    # Check if lookup_value is a DataFrame
    if isinstance(lookup_value, pd.DataFrame):
        lookup_value_list = lookup_value.values.flatten().tolist()
    else:
        lookup_value_list = [lookup_value]
    
    results = [] 
    for lookup_value_item in lookup_value_list:
        # Calculate similarity scores and round to 2 decimal places
        scores = [(index + 1, round(algo_func(lookup_value_item, item), 2)) for index, item in enumerate(lookup_array)]
        
        # Sort based on scores in descending order
        scores.sort(key=lambda x: x[1], reverse=True)
        # Append the top index and score to results as a list
        results.append(list(scores[0]))

    # results is 2D list, e.g. [[1, 0.75], [2, 0.85]]
    return results

nltk_distance(arg1, arg2, arg3)

The nltk_distance function takes three arguments:

• lookup_value: The string or DataFrame to search for, e.g. "apple" or pd.DataFrame(["apple", "banana"]).
• lookup_array_df: The DataFrame to search within, e.g. pd.DataFrame(["apples", "bananas", "cherries"]).
• algorithm: The algorithm to use for calculating similarity. Options are 'levenshtein', 'jaccard', and 'jaro'.

The function returns a list of lists, where each sublist contains the index (1-based), similar to XMATCH, and the similarity score of the most similar item in the lookup_array. For example, [[1, 0.75], [2, 0.85]] indicates that the most similar item to the first lookup_value has an index of 1 and a similarity score of 0.75, and the most similar item to the second lookup_value has an index of 2 and a similarity score of 0.85. This matches the array output expected by Excel.

Use in Excel​

EXCEL PY()​

In an Excel PY() cell, start by assigning the values of the function arguments arg1, arg2, arg3 to the appropriate data in the workbook, then paste the function code below it. For example, if the range A6:A10 contains the lookup values, the range B6:B27 contains the lookup array, and the cell C6 contains the algorithm name, we get the following in the Excel PY() cell:

=PY(
arg1 = xl("A6:A10") # lookup_value
arg2 = xl("B6:B27") # lookup_array_df
arg3 = xl("C6") # algorithm

def nltk_distance(lookup_value, lookup_array_df, algorithm):
# ... function code omitted for brevity ...
    return results

nltk_distance(arg1, arg2, arg3)
)

BOARDFLARE.RUNPY()​

Assuming the code is contained in cell A1, we can get the same result using the BOARDFLARE.RUNPY function as follows:

=BOARDFLARE.RUNPY(A1, A6:A10, B6:B27, C6)

Since nltk_distance is in our functions library, you can call it using the path text/fuzzy-match/nltk_distance.ipynb, and the latest code will be downloaded and executed. For example:

=BOARDFLARE.RUNPY("text/fuzzy-match/nltk_distance.ipynb", A6:A10, B6:B27, C6)

One of the benefits of using the BOARDFLARE.RUNPY function is that we can further customize it in Excel using a LAMBDA function. For example, if we want to set a similarity threshold, as follows:

=LAMBDA(lookup_value, lookup_array, [similarity_threshold], [algorithm],
    LET(
        threshold, IF(ISOMITTED(similarity_threshold), 0.7, similarity_threshold),
        algo, IF(ISOMITTED(algorithm), "jaccard", algorithm),
        result, BOARDFLARE.RUNPY("text/fuzzy-match/nltk_distance.ipynb", lookup_value, lookup_array, algo),
        index, INDEX(result, 1),
        score, INDEX(result, 2),
        IF(score >= threshold, index, "No match")
    )
)

Conclusion​

Fuzzy matching is a powerful tool for handling approximate string matching in various applications. The nltk_distance Python function provides a flexible and easy-to-use interface for performing fuzzy matching using different algorithms. It can be run efficiently in Excel using either the Excel PY() or BOARDFLARE.RUNPY functions, enabling users to leverage the power of Python within their Excel workbooks.

Background​

Azure Sentiment Analysis is a cloud-based service, part of Azure AI Language, that uses machine learning to analyze text for sentiment and opinions. It returns an array containing the sentiment analysis results with sentiment polarity at the document, sentence, and aspect levels. It also provides the opinions used at the aspect level. This is often referred to as aspect-based sentiment analysis.

For example, given the text "I love the food, but the service was terrible", instead of just getting a single sentiment score, which in this case isn't that useful, we can extract the sentiment for each aspect, such as food = positive and service = negative.

The table below is a contrived example where the aspects have purposely been made to relate to either a food or service type aspect. These aspects were not extracted by the Azure Sentiment Analysis service, but are used here to illustrate the concept of aspect-based sentiment analysis.

Notice how the words used to describe food and service related aspects are varied, so trying to group them by keyword isn't practical as the following different words are used for food: pizza, pasta, cuisine, menu items, appetizers, ingredients, dishes, food quality, menu selection, entrees.

To properly summarize the results we need to group the aspects together using semantic similarity, typically into clusters of related words. This is beyond the scope of this article.

Python Function​

To access the Azure Sentiment Analysis service from Excel, we're going to create a Python function that calls the Azure API and returns the sentiment analysis results. We'll use the azure-ai-textanalytics Python library which provides a simple interface to the Azure Text Analytics service. In our function we'll pass in the array of text to analyze, the Azure key, and the Azure endpoint. We want the results in a tabular format, so we need to flatten the structure so that each row contains the sentiment analysis results for a single aspect, and thus there are multiple rows per review.

from azure.ai.textanalytics import TextAnalyticsClient
from azure.core.credentials import AzureKeyCredential

def azure_sentiment(documents, language_key, language_endpoint):
    # Check if documents is a string, list, or DataFrame
    if isinstance(documents, str):
        documents = [documents]
    elif isinstance(documents, pd.DataFrame):
        documents = documents.values.flatten().tolist()  # Convert df to list

    # Authenticate the client using your key and endpoint 
    ta_credential = AzureKeyCredential(language_key)
    client = TextAnalyticsClient(
            endpoint=language_endpoint, 
            credential=ta_credential)

    result = client.analyze_sentiment(documents, show_opinion_mining=True)
    doc_result = [doc for doc in result if not doc.is_error]

    data = []

    for idx, document in enumerate(doc_result):
        for sentence in document.sentences:
            for mined_opinion in sentence.mined_opinions:
                target = mined_opinion.target
                for assessment in mined_opinion.assessments:
                    data.append([
                        idx + 1,  # 1-based index
                        document.sentiment,
                        document.confidence_scores.positive,
                        document.confidence_scores.neutral,
                        document.confidence_scores.negative,
                        sentence.text,
                        sentence.sentiment,
                        sentence.confidence_scores.positive,
                        sentence.confidence_scores.neutral,
                        sentence.confidence_scores.negative,
                        target.text,
                        target.sentiment,
                        target.confidence_scores.positive,
                        target.confidence_scores.negative,
                        assessment.text,
                        assessment.sentiment,
                        assessment.confidence_scores.positive,
                        assessment.confidence_scores.negative
                    ])
    return data

azure_sentiment(arg1, arg2, arg3)

Output​

The figure below illustrates an example of the results returned by the Azure Sentiment Analysis service for a single document that contains two sentences as follows: The food and service were unacceptable. The concierge was nice, however...

The results are then flattened or denormalized into a tabular format where each row contains the sentiment analysis results for a single aspect and duplicates the parent sentence and document. The columns in the output include the document index, document sentiment, document confidence scores, sentence text, sentence sentiment, sentence confidence scores, aspect text, aspect sentiment, aspect confidence scores, opinion text, opinion sentiment, and opinion confidence scores.

Excel Integration​

To run this function from Excel we need to use the BOARDFLARE.RUNPY function which is available in the Boardflare Python for Excel add-in. This function allows you to run Python code from Excel and return the results in a tabular format. The BOARDFLARE.RUNPY function takes a path to the Python code as the first argument, followed by the arguments to pass to the Python function.

=BOARDFLARE.RUNPY("text/sentiment-analysis/azure_sentiment.ipynb", A1:A10, "your-azure-key", "your-azure-endpoint")

Results​

As shown in the workbook, running the table of reviews earlier through the Azure Sentiment Analysis generates the following high-level sentiment analysis results:

Most of the columns in the output were omitted for brevity.

Conclusion​

In this article we have shown how to use the Azure Sentiment Analysis service from Excel to analyze sentiment and opinions in text. We have also shown how to flatten the results into a tabular format so that they can be easily analyzed in Excel. This is a powerful tool for analyzing sentiment in text data, and can be used in a variety of applications such as customer support, market research, finance, etc. We have left the task of summarizing the results into clusters of related aspects as an exercise for the reader.

🆕 BOARDFLARE.RUNPY function​

To achieve compatibility with Python in Excel, we've introduced a new BOARDFLARE.RUNPY function that handles both scalar and array inputs and outputs, and therefore replaces the original BOARDFLARE.PY and BOARDFLARE.PY.ARRfunctions which are now deprecated. We chose the name RUNPY to reduce potential confusion with Excel's PY feature and we are not that creative with names.

Like Python in Excel, BOARDFLARE.RUNPY now converts Excel arrays into pandas DataFrames. It also returns the value of the last expression in the Python code, instead of using pyout as the output variable. This approach not only aligns with Python in Excel, but also with Jupyter notebooks.

The net result is that the same function code will work in both, with the only difference being how data is passed as arguments as shown in the following examples:

# Using BOARDFLARE.RUNPY
def add(a, b):
  return a + b

add(arg1,arg2)

Assuming the code above is in cell C2, the arguments arg1 and arg2 are passed to the BOARDFLARE.RUNPY function as follows:

=BOARDFLARE.RUNPY(C2, A2, B2)

With Python in Excel, the same code would be written as follows:

# Using Excel's PY
def add(a, b):
  return a + b

add(xl("A2"),xl("B2"))

Here the xl function is used to reference the Excel cells A2 and B2 inside the Python code. The upside of Microsoft's approach is everything is all in one cell, so is easier to make changes when developing code interactively. The downside is that it is not a function, and therefore can't be used in Excel formulas or LAMBDA functions the way BOARDFLARE.RUNPY can.

Functions collection​

We're just getting started on building out a collection of ready-to-use Python functions that can also be used as a starting point for building more complex functions.

For example, we've built a text_distance function for fuzzy matching that is similar to that used in our Fuzzy Match app, but supports many more algorithms and can be readily modified to your specific needs. Here's the code:

import textdistance
import pandas as pd

def text_distance(needle, haystack_df, algorithm='jaccard'):
    # Get the algorithm function from textdistance
    algo_func = getattr(textdistance, algorithm)
    # Flatten the DataFrame to a list
    haystack = haystack_df.values.flatten().tolist()
    
    # Check if needle is a DataFrame
    if isinstance(needle, pd.DataFrame):
        needle_list = needle.values.flatten().tolist()
    else:
        needle_list = [needle]
    
    results = [] 
    for needle_item in needle_list:
        # Calculate similarity scores with normalization and round to 2 decimal places
        # Adjust index to be 1-based
        scores = [(index + 1, round(algo_func.normalized_similarity(needle_item, item), 2)) for index, item in enumerate(haystack)]
        # Sort based on scores in descending order
        scores.sort(key=lambda x: x[1], reverse=True)
        # Append the top index and score to results as a list
        results.append(list(scores[0]))

    # results is 2D list, e.g. [[1, 0.75], [2, 0.85]]
    return results

text_distance(arg1, arg2, arg3)

LAMBDA functions using Python​

One of the great features of BOARDFLARE.RUNPY is that it can be used to build LAMBDA functions that can be used in Excel formulas. For example, the text_distance function can be used to build a FUZZYMATCH.TD function that is similar to Excel's XMATCH function, but with the added ability to set a similarity threshold. Here's the code:

=LAMBDA(lookup_value, lookup_array, [similarity_threshold], [algorithm],
    LET(
        threshold, IF(ISOMITTED(similarity_threshold), 0.7, similarity_threshold),
        algo, IF(ISOMITTED(algorithm), "jaccard", algorithm),
        result, BOARDFLARE.RUNPY("text/fuzzy/text_distance.ipynb", lookup_value, lookup_array, algo),
        index, INDEX(result, 1),
        score, INDEX(result, 2),
        IF(score >= threshold, index, "No match")
    )
)

The Python in Excel feature is only available to Microsoft 365 subscribers, and access to the higher performance runtime requires a separate add-on license.

The purpose of this post is to focus on the strengths and potential weaknesses of this implementation and to explore alternatives.

Strengths​

• Directly reference cells: Users can reference cells in Excel directly from Python code using the python xl function, e.g. foo = xl(A1). This makes it super easy to use Excel data in Python code, similar to how you would with Excel formulas.

• Outputs Python object or Excel values: Users can select whether the value returned is a Python object or Excel values. This is useful for when you want to use the output in further Python code or in Excel formulas.

• Consistent Python runtime: An Anaconda Python runtime running in the Microsoft cloud which provides a consistent version of packages and performance for all users regardless of their local machine.

• Microsoft Copilot integration: This is currently in beta, but provides a great way for non-programmers to get started with Python code in Excel.

Potential Weaknesses​

We realize all of these weaknesses could be considered strengths, depending on the needs of the target market, and we're sure the Excel product team explicitly chose to do things this way for a reason. However, in some of the use-cases we're familiar with, these could be considered weaknesses.

• No custom packages: The Python runtime is limited to the packages available in the Anaconda distribution, which is quite comprehensive, but may lack something specific you need.

• No internet access: Your Python does not have access to the internet, so you cannot do things like access OpenAI models, call APIs, etc. This basically limits you to analyzing the data in your workbook.

• PY is not an Excel function: While PY appears to be an Excel function, you can't use it as a function in formula. For example, if you want to create a LAMBDA that embeds some Python code using PY, e.g. =LAMBDA(x, PY(x + 2)), this does not work.

• Code is stored in workbook: The Python code is embedded directly in the xlsx file, which is consistent with the Excel paradigm. However, this means that any code changes must be copied manually to each workbook containing it rather than being managed centrally with version control.

• Code does not run locally: Since the Python runtime is in the Microsoft cloud, the code cannot run locally, which can create security issues for some, lack of offline capability, and a dependence on Microsoft cloud for performance.

• Python cells share state: The Python cells are executed in the order they appear in the workbook, and they share state, similar to a Jupyter notebook. This is both a positive and a negative, and can make it difficult to debug and understand the code.

See also this great post by xlwings on these and some other potential weaknesses.

Alternatives​

PyXLL​

PyXLL is package for Windows only which enables developers to build traditional Excel add-ins (not modern web-based add-ins) using Python. The Python runtime is running on Windows so it is able to use virtually all Python libraries, including those that use C and C++ extensions.

xlwings​

xlwings comes in two variants. The client product runs on Windows or Mac and is similar to PyXLL in terms of being able to build traditional Excel add-ins. The xlwings Server is used to create modern Excel web add-ins entirely in Python by deploying a web app using Python code, similar to Streamlit or Gradio. This is a very clever strategy that eliminates the need for a separate Excel add-in web app which calls a Python API. They are also working on an xlwings Script version which will run in the browser, which sounds very promising.

Anaconda Code​

Anaconda partnered with Microsoft to provide Python in Excel. Shortly after the the Python in Excel beta was released in August 2023, Anaconda released the Anaconda Toolbox which initially was focused on providing a no-code AI assistant for Python in Excel as well as a way to centralize the storage of external data. In July 2024, Anaconda Code was added to the toolbox, which enabled users to run Python code locally in Excel using PyScript, which in turn uses Pyodide. This targeted a different set of users than the Microsoft implementation, as it allowed for internet access, custom packages, and local execution. It is unclear if this was planned all-along, or if it was a response to the limitations of the Microsoft implementation.

It uses the REF(A1) function syntax to reference cells in Excel from within Python code, similar to the xl(A1)syntax used by Python in Excel.

Python for Excel​

Boardflare's Python for Excel was just launched into beta and is the latest addition to the available options. It is a free add-in that is similar to Anaconda Code in that it enables users to run Python code locally in Excel using Pyodide.

Some of the key benefits are as follows:

🆓 Free add-in, no Microsoft 365 license required.
🌐 Works in Excel for web as well as desktop.
☁️ Runtime has network access for API calls.
📦 Import custom packages (pure Python only).
🔒 Runs locally, so no data is shared outside Excel.
✅ Can be used inside formulas and LAMBDA functions.
➡️ Code can be centralized and loaded from a URL.
🚀 Performance is only limited by your CPU.

Conclusion​

Python in Excel is a great addition to the Excel ecosystem, and we're excited to see how it evolves. There are now several options available for running Python code in Excel, each with their own strengths and weaknesses. We hope this post has helped you understand the differences between them and choose the one that best fits your needs.

It is currently available to Beta Channel users on Windows and Mac. It is unclear if this will offer unlimited free use once it reaches GA.

Functions​

TRANSLATE​

The TRANSLATE() function translates text from one language to another using Microsoft Translation Services.

=TRANSLATE(text, [source_language], [target_language])

The function has the following arguments:

• text: The text to translate, either in quotation marks or as a cell reference.
• source_language (optional): The language code of the source language (e.g., "en" for English, "es" for Spanish). If not specified, the language is auto-detected. Specifying the language is recommended for shorter texts.
• target_language (optional): The language code of the target language (e.g., "en" for English, "es" for Spanish). If not specified, the system language is used.

Supported languages and their codes can be found in Supported Languages and Language Codes.

For example, to translate the text "Hello, World!" in cell A1 to Spanish, use:

=TRANSLATE(A1, "en", "es")

Here, the source language is English ("en") and the target language is Spanish ("es"). The translated text "Hola mundo!" will appear in the cell with the formula.

DETECTLANGUAGE​

The DETECTLANGUAGE() function is used to identify the language in a specified text or range.

The syntax for the DETECTLANGUAGE() function is as follows:

=DETECTLANGUAGE(text)

The function has the following arguments:

• text - The text or reference to cells containing text.

Supported Languages.

For example, if you have the following text in cell A1: "Hola mundo!" and you want to find out what the language of the text is. You can use the DETECTLANGUAGE() function as follows:

=DETECTLANGUAGE(A1)

This will return the detected language for the text in cell A1. The language code "es" for Spanish will be displayed in the cell where you entered the formula.

Alternatives​

The TRANSLATE function is similar to the GOOGLETRANSLATE function in Google Sheets and the Translate for Excel function provided by BoardFlare.

The main advantages of Boardflare's Translate for Excel are as follows:

• no throttling or quotas on usage.
• your data stays in Excel and is not shared.

Updated: Microsoft has announced their own new native TRANSLATE function for Excel. See this post.

GOOGLETRANSLATE​

GOOGLETRANSLATE is a popular function in Google Sheets that allows users to translate text directly within their spreadsheets. It's a powerful tool for working with multilingual data and has become an essential feature for many users. It translates text from one language to another with a simple function syntax of GOOGLETRANSLATE(text, [source_language], [target_language]).

Translate for Excel​

Translate for Excel is a function similar to GOOGLETRANSLATE, but for Excel. It uses a machine learning model to translate text directly within your spreadsheet. This means your data never leaves your document, ensuring privacy and security. Since it runs on your CPU, there are no usage limits or api fees.

Key Features​

Translate for Excel offers several key features:

• Translation of 20 languages to or from English: We plan to expand the languages supported and enable translation between any pair of languages.
• Unlimited free use: There are no usage limits or fees.
• Local operation: The function runs on your computer, so your data remains secure.

How to Use Translate for Excel​

Using Translate for Excel is simple. The function requires only the text you want to translate and the language code of the input text. Here's how you can use it:

=BOARDFLARE.TRANSLATE(text, source_language, target_language)

For example, to translate a cell A1 from Spanish to English, you would use:

=BOARDFLARE.TRANSLATE(A1, "es", "en"    )

Installation​

You can install Translate for Excel from the Microsoft AppSource store or directly from Excel.

Conclusion​

Translate for Excel fills a significant gap in Excel's functionality, providing a powerful translation tool directly within your spreadsheet. While it's not as fast as GOOGLETRANSLATE, it offers the advantage of privacy, security, and unlimited free use. We're excited to see how this function will empower Excel users to work more effectively with multilingual data.

Background​

In Google Sheets extensions, Google Apps Script is used to serve the HTML page for the sidebar in the UI. To do machine learning (or any other intensive processing) client-side, ideally you want to use a web worker so the UI can remain responsive (e.g. to report on progress, cancel the operation, etc.) and also to enable multi-threaded processing.

Problem​

Google Apps Script doesn't support serving a worker script directly from a file.

Solution​

We'll use the inline worker pattern. The first step is to put the worker code in an html file in the Google Apps Script project, e.g. worker.html, with no html tags as shown below.

self.onmessage = function(e) {
  console.log('Message received from main script');
  var workerResult = 'Result: ' + (e.data[0] * e.data[1]);
  console.log('Posting message back to main script');
  self.postMessage(workerResult);
}

Next, we inline the worker code in the main HTML file using a Google Apps scriptlet to assign the text contents of the worker.html to a variable. Note the <?!= syntax with the exclamation mark to prevent escaping of the script. After that we create a blob and object URL, and then a new Worker using the object URL. In our case we use the type: 'module' option on the Worker constructor, which creates a module worker, which we need for the ESM-only library we are using in the worker.

<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
  </head>
  <body>
    <script type="module">
    var workerScript = `<?!= HtmlService.createTemplateFromFile('worker').evaluate().getContent() ?>`
    var blob = new Blob([workerScript], {type: 'application/javascript'});
    var workerUrl = URL.createObjectURL(blob);
    var worker = new Worker(workerUrl, {type: 'module'});
    worker.onmessage = function(e) {
      console.log(e.data);
    };
    worker.postMessage('Start processing data');
    </script>
  </body>
</html>

One problem with this approach is that worker.html, without script tags, is not treated by a code editor as JavaScript, so no syntax highlighting, etc. You could add script tags in the worker.html file to fix this and then strip them back out again from the string in workerScript before passing it into the blob. In our case we're developing the worker code in a plain web app first before copying it into the Google Apps Script project, so this isn't an issue.