The output is a real, distributable add-in. xllify helps you build, handles the complexity, and gets out of the way.
Create your custom functions directly in Excel
Work in Claude Code, if you'd prefer (coming soon)
Who is this for?
xllify is built for people who live in Excel and need more than formulas, and for the teams that build and sell software aimed at them.
Data & software vendors
You already have the product, so it is not a huge reach to give your customers native Excel functions that pull your data or run your models live in their spreadsheets. An additional revenue stream, a stickier product, and no C++ or .NET codebase for your team to maintain.
Analysts & finance teams
You have calculations that live in formulas spread across hundreds of cells. Package them as functions your team calls by name: consistent, auditable, impossible to accidentally overwrite.
Trading desks
Build pricing curves, simulations, and risk models that run at native speed inside Excel. Deploy centrally so every trader gets the same locked-down logic. Tidy workbooks, protected IP, and data volumes well beyond what formulas can handle.
Not enough hours in the day? We work with teams on a consultancy basis to deliver add-ins end to end. Because we built (and use!) xllify, the cost tends to be a lot lower than you might expect. Get in touch.
Custom functions vs formulas
Formulas are the right tool most of the time. Custom functions extend what's possible, unlocking benefits that formulas alone can't provide.
Centralised, locked-down logic
Filling formulas down columns creates hundreds of copies that can be accidentally edited or deleted. Define it once as a function, and every cell calls the same logic.
Easier to audit, harder to tamper with
One definition to review instead of hundreds of cells. Find and fix errors in one place. With formulas, your logic is fully exposed: anyone who opens the file can read, copy, or quietly change your calculations. A compiled add-in makes that significantly harder.
Faster to change
Fix or improve the function, rebuild, and every sheet that uses it is updated. Test your logic outside of Excel before deploying.
Ready to ship
Package your functions into a single add-in. Deploy internally, share with colleagues, or sell it as a product. The output is standalone: end users just install it with no runtime to manage, no added costs for you, and no dependency on xllify.
What xllify provides
Rapid results
xllify Assistant writes a first draft after you've described what you need in plain English, or pasted existing formulas and VBA. You review, edit the code directly, and iterate with coding assistance on hand. Once built, your add-in runs the same way every time with no AI involved.
Verified standard library
A curated set of optimised, pre-built functions for common operations, built on native primitives for performance-critical work. The Assistant uses these directly rather than generating new code, so results are faster, more reliable, and available in your own functions too.
Remote builds
You have nothing to install. Built and packaged in seconds. No local tooling required.
Cross-platform runtime
One codebase runs on Windows, Mac and Excel for the web.
Desktop-speed calculations
Native Windows add-ins run at full speed inside Excel. Multi-threaded, single-file, no server required.
Safe to share
Native builds can't access your files or network. The sandboxed design means they're safe to distribute.
Try instantly in Excel for the web
Preview your functions in Excel for the web without installing anything. We handle the hosting.
Yours to own
No phone home, no analytics, no per-seat licences. Rebuild and update as often as you need.
How does xllify compare to other approaches?
Microsoft 365 Copilot & Claude for Excel
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.
VBA, LAMBDA & other tools
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. 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 for Windows, packaged as a single file with no dependencies for the end user.
Office.js (Office Add-ins)
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.
C API / Excel SDK
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.
How it works
xllify is a platform for creating custom Excel functions. Describe what you need in a prompt, or write code directly. Work in the browser, in Excel via the xllify Assistant add-in, or locally with the xllify agent (coming soon).
xllify prioritises verified, tested implementations from the standard library before generating new code. The standard library includes native C++ primitives for performance-critical operations, available to every function, including those generated by AI. The runtime is available for Windows, Mac and Web.
Accelerated on Windows: In addition to cross-platform web add-ins, xllify can build native XLL add-ins for Windows. XLLs run in-process with Excel with multi-threaded recalculation, self-contained in a single file with no web server or internet connection required. No local tooling needed: xllify handles everything through a remote build service.
Function code runs in a sandboxed VM with no access to the network or file system, so XLLs built with xllify cannot be used as an attack vector. Both runtimes execute the same bytecode, so functions work identically everywhere. XLL builds are in preview and available to all users. Builds expire after thirty days.
Remote build service
xllify compiles and packages your add-ins in the cloud. You have nothing to install. Write your functions in the browser or in Excel, and xllify produces a ready-to-use add-in in seconds. This applies to both Office Add-ins and native XLL builds for Windows. Fair use applies.
Pricing
Free
- Build in your browser or Excel
- Office add-in hosted previews and downloadable builds
- Native XLL builds with 30-day expiry
- AI assistant included
- xllify standard library access
- Support for xllify issues
- Personal, non-commercial, non-profit use only
Early adopter
- Permanent XLL builds
- No xllify branding
- Multiple add-in projects
- Higher AI coding assistance usage rates
- Priority email support for xllify issues
- Distribute to unlimited end users
- Roadmap, included as they land
- Local development
- External data
- RPC
- Office Add-in hosting with Microsoft Entra auth
- RTD / async functions
Microsoft account required. Please use the same email address at checkout. We will personally be in touch with you after purchase.
Early adopter signup