xllify

Copilot (and tools like Claude for Excel) are great at helping you work inside Excel: writing formulas, generating VBA macros, analysing data, and creating charts. If you need a one-off calculation or a quick macro in a single workbook, they can get you there fast.

What they can't do is produce a distributable add-in. Their output (formulas, LAMBDA names, or VBA) lives inside the workbook it was created in. Share the file and the code goes with it, fully visible and editable by anyone who opens it. There's no compilation, no IP protection, and no way to package the result as a standalone product. Copilot also requires a paid Microsoft 365 Copilot licence; Claude for Excel requires an Anthropic Pro subscription.

xllify is built for a different job: turning function logic into a real add-in you can distribute. It provides a high-level scripting environment that AI can reliably generate code for, and executes it on multiple runtimes (native XLL on Windows, web add-in everywhere else). Your end users install the add-in and use your functions; they never see your code. It's the difference between asking AI to help you inside a spreadsheet and using AI to build a reusable component you can sell as a product.

There's also a fundamental difference in how the output behaves. Copilot is non-deterministic; ask it the same thing twice and you may get a different answer. In xllify, the xllify Assistant helps you through every iteration before you build: writing the initial code, refining the logic, and testing it in the built-in editor. Once you're happy, that code runs identically every time—and the xllify Assistant is always there to help you refine and extend it when you need to.

There are many good ways to extend Excel. VBA and LAMBDA are built in and require nothing extra. Excel-DNA prioritises raw performance for .NET developers, producing native XLLs with deep Excel integration. PyXLL and xlwings bring the Python data ecosystem to Excel with rich feature sets spanning custom functions, task panes, and more. Microsoft's own Python in Excel runs Python remotely in the cloud via Anaconda, and like Copilot, requires a paid Microsoft 365 subscription. xllify covers far less ground — it focuses solely on custom functions — but removes all setup and tooling from the picture, and once built, everything runs locally.

xllify takes a different approach. There's no local development environment to set up, no language runtime to install, and no build tooling to manage. Describe what you need in plain English, paste a formula or VBA, or write code directly, and xllify produces a ready-to-distribute add-in in seconds. The output runs cross-platform as a web add-in or as a native XLL on Windows, packaged as a single file with no dependencies for the end user.

Office.js is Microsoft's official platform for building cross-platform Excel add-ins using web technologies (HTML, CSS, JavaScript/TypeScript). It works on Windows, Mac, and the web, and supports custom functions, task panes, and ribbon commands. It's the direction Microsoft is investing in.

Building with Office.js means setting up a Node.js project, configuring a manifest, hosting your add-in on a web server, and dealing with the custom functions runtime model. The developer experience has improved but remains involved, especially for someone who just wants to ship a few functions. Distribution is also non-trivial: you need to host the add-in, manage the manifest, and either sideload or publish through the Office Store.

xllify uses Office.js under the hood for its web add-in output, but abstracts away all the setup. You get a working add-in without touching manifests, webpack, or deployment. For native Windows performance, xllify also produces XLLs, which are single-file downloads anyone can open. Hosted add-in distribution is on the roadmap. xllify is currently focused on custom functions, with async and RTD in development.

The C API is the lowest-level way to build XLLs. It gives you maximum performance and full control over Excel integration, including worksheet functions, menu commands, and dialog boxes. It's the foundation that xllify's own runtime is built on.

The trade-off is complexity. You're writing C or C++, managing memory manually, and working with Excel's XLOPER data structures directly. Registration, type conversion, and error handling are all on you. Code is extremely verbose and error-prone, documentation is quite old, and the last SDK release, although stable and perfectly functional, was over twelve years ago. Build tooling is non-trivial and Windows-only.

xllify handles all of that infrastructure so you can focus on function logic. You write in Luau (or plain English via the xllify Assistant), and xllify produces a single-file XLL ready to distribute. Send it to a colleague, deploy it to a team, or sell it to clients. No installer, no dependencies, no setup on the receiving end. If you need deep Excel integration beyond custom functions, the C API remains the right tool. xllify is focused on custom functions, with async and RTD support in development.