Microsoft Calculator: building the Windows Calculator source from the repository

What the Windows Calculator repository actually contains

This is not a general-purpose calculator library. It is the source of the app that ships pre-installed with Windows, written in C++ and C# as a UWP application, and released under the MIT License. If you are looking for a component to embed in a service or a Linux tool, nothing here fits.

The functionality described in the README covers standard, scientific and programmer modes, date calculation, history and memory, unit conversion, and currency conversion. One detail stands out for anyone who has been burned by floating point: the README claims infinite precision for basic arithmetic (addition, subtraction, multiplication, division), so those operations do not lose precision. That is a claim about the shipped app, not something you can assume about the interface layer if you rewrite parts of it.

The audience is narrow but real. People who modify the shipped app, people who want to study how a production UWP calculator is structured, and people who want the graphing UI. Everyone else should probably use something else.

How the app is put together and where graphing stops

The repository layout separates concerns more cleanly than a typical sample. The solution lives at src/Calculator.slnx, and the README points to docs/ApplicationArchitecture.md for the architecture description. The graphing story is the part worth understanding before you clone anything.

The README states that the UI from the official in-box Windows Calculator is part of this repository, but the proprietary Microsoft-built graphing engine is not. That engine also drives graphing in Microsoft Mathematics and OneNote. What you get instead is a mock implementation under src/GraphingImpl/Mocks, built on top of a common graphing API under src/GraphingInterfaces. The README says developer builds will not have graphing functionality because of that mock.

So the data flow for graphing is: your UI code talks to the interface definitions, and the only implementation present is a stub. Anything you build on top of it is your own engine or a third-party one wired into those interfaces. The interfaces are the contract; treat them as the deliverable, not the mock.

Two other build-level details are visible in the README. Diagnostic data is disabled in development builds by default and can be enabled with the SEND_DIAGNOSTICS build flag. The currency converter in developer builds uses mock data that references planets instead of countries and stays static regardless of input, because the data Microsoft uses in the retail app is not licensed for your use.

Installing the build prerequisites and running from source

There is no package manager install path here. The README gives one route: build from source in Visual Studio on Windows. The prerequisites are specific, so check them before you start. Your machine must run Windows 11, build 22000 or newer.

Install the latest Visual Studio, where the free community edition is sufficient, and add three things during setup: the Universal Windows Platform Development workload, the optional C++ Universal Windows Platform tools component, and the latest Windows 11 SDK. The README also asks for the XAML Styler extension from the Visual Studio Marketplace.

With those in place, clone the repository:

git clone https://github.com/Microsoft/calculator.git

Then open src/Calculator.slnx in Visual Studio to build and run the app. If you want to run the UI tests, the README says Windows Application Driver (WinAppDriver) must be installed, and it links to the latest WinAppDriver release.

For end users who just want the app, the README points to the Microsoft Store listing rather than a source build. That is the practical install path for anyone who is not modifying the code.

The graphing engine gap and other limits you should plan around

The largest constraint is the missing graphing engine. The README is explicit that developer builds will not have graphing functionality. If graphing is the reason you came, you are adopting a UI and a set of interfaces, and you supply the math. That is a substantial amount of work hidden behind a feature that appears on the roadmap.

The currency converter has a similar shape. In developer builds the data is mock data referencing planets, and it remains static regardless of selected inputs. The README states the real data is not licensed for your use. Anyone evaluating this repository for a currency feature should read that as a hard boundary rather than a configuration problem.

Platform is the other boundary. The prerequisites start at Windows 11 build 22000, and the app is UWP. There is no documented path for Windows 10 despite the repository carrying a windows-10 topic, and no path for macOS or Linux. If you need a calculator on those platforms, this is the wrong tool, and no amount of porting effort is described in the README.

Diagnostic data is worth a look before you ship a fork. The project collects usage data and sends it to Microsoft, and the README links to a privacy statement. Development builds disable it by default, which is the behaviour you want, but the SEND_DIAGNOSTICS flag means it can be turned back on.

Alternatives and when a different calculator project is the better call

The obvious alternative for most people is not another open source project at all: it is the Microsoft Store version of Calculator, which the README recommends for getting the latest version. That version includes the graphing engine and the licensed currency data. You get the finished product instead of a build harness around a missing engine. The trade-off is that you cannot change the app.

If you need a calculator as a library rather than an application, the repository does not offer one. The code is organized as a Windows app, and the README describes application features, not an API surface you can call from another program. A language-native arbitrary-precision library, or a small expression parser, would be the smaller dependency for that job. The difference in approach is that those give you a function to call, while this gives you a UWP app to modify.

If the appeal is the graphing UI specifically, the comparison is between this repository and building the whole thing yourself. Here you get the interface definitions in src/GraphingInterfaces and a mock to develop against. Elsewhere you would define your own interfaces and write the UI as well. The repository saves you the UI work and the interface design, and nothing else.

For cross-platform needs, none of these options match. The README describes a Windows app, and the prerequisites confirm it.

Licence, maintenance and what a fork costs you

The repository is licensed under the MIT License, with a NOTICE.txt at the top level. MIT is permissive, and the README states the copyright line as Microsoft Corporation. What that does not cover is the missing graphing engine, which is proprietary and simply not in the repository, and the currency data, which the README says is not licensed for your use. A permissive licence on the code does not grant you either of those, and the README is clear about the second one. This is a description of the licence text and the README, not legal advice; if the distinction matters to your product, have someone qualified read the files.

On maintenance: the last push to the main branch was on 2026-08-25, and the repository is not archived. That is recent activity by the only measure available here, but the README also states that Calculator ships regularly with new features and bug fixes, and points to docs/Roadmap.md for plans and release schedule. Read the roadmap before you plan a long-lived fork, because a fork has to absorb upstream changes you did not write.

The upgrade cost of forking is the part people underestimate. You are maintaining a UWP app against a moving Windows SDK and a moving Visual Studio toolchain, with a solution file at src/Calculator.slnx and a XAML codebase that expects XAML Styler formatting. Every SDK bump is your problem. If you only need the app, the Store version carries that cost for you.

Editorial conclusion

Adopt this repository if you are targeting Windows 11 build 22000 or newer and want to read or change the shipped Calculator app itself, or if you want the graphing UI around the interface stubs in src/GraphingInterfaces. Do not adopt it if you need a cross-platform calculator, a working graphing engine, or a currency converter with real rates, because developer builds ship a mock engine and planet-based mock currency data. Before committing, verify that src/Calculator.slnx opens under your Visual Studio install with the Universal Windows Platform Development workload and the C++ UWP tools component, and confirm that the graphing mock in src/GraphingImpl/Mocks is an acceptable starting point for what you intend to build.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. microsoft/calculator on GitHub
4. README