xllify

· Alex · 2 min read

Excel's fastest custom functions are also the hardest to build. xllify changes that.

XLL add-ins are Excel's highest-performance extension mechanism, but Microsoft say they're impractical for most developers. xllify changes that.

If you have ever written a complex Excel formula and wondered why it takes seconds to recalculate across thousands of rows, the answer is almost certainly that your worksheet functions are running single-threaded, interpreted, and out-of-process.

There is a better option. It has existed since Excel 4. Almost nobody uses it.

XLL functions are genuinely fast

XLL add-ins run inside the Excel process itself. Your function gets called directly by Excel’s calculation engine, with no serialization, no inter-process communication, no interpreter overhead. On top of that, Excel can call your functions across multiple threads simultaneously. Your 8-core machine can be running 8 of your custom functions in parallel during a recalculation.

Microsoft’s own docs describe XLLs as providing “the most direct and fastest interface for the addition of high-performance worksheet functions.”

Python in Excel runs behind a service. Office Add-ins communicate over a bridge. VBA is single-threaded. XLL is none of those things.

So why doesn’t everyone use them?

Because they are extremely hard to build.

XLLs are native Windows DLLs, written in C or C++, using an SDK that has been around since the early 1990s. Memory management is entirely manual. The type system is low-level. There is almost no tooling.

Microsoft put it plainly in their own documentation: “the investment in time to obtain the understanding and skills that are required to write XLLs make this a technology impractical for most users.”

That is a remarkable admission. The fastest way to extend Excel is also the one Microsoft themselves describe as impractical.

xllify closes the gap

xllify wraps the XLL runtime so you never touch the C SDK. You write a function in Luau (a clean, simple scripting language), describe its parameters, and get a native XLL back. Multi-threaded recalculation is on by default. The output is a single .xll file with no dependencies.

xllify.ExcelFunction({
    name = "FastCalc",
    parameters = {
        { name = "values", type = "number", dimensionality = "matrix" }
    },
    execution_type = "sync"
}, function(values)
    local sum = 0
    for _, row in ipairs(values) do
        sum = sum + row[1]
    end
    return sum
end)

That is the whole function. Build it, load the XLL, call =FastCalc(A1:A10000). Excel calls it on a worker thread, in-process, as fast as it can go.

If you have worksheet functions that need to be genuinely fast, not just “fast enough”, this is the path. It used to require a C++ developer and weeks of SDK archaeology. Now it does not.

← All posts