> ## Documentation Index
> Fetch the complete documentation index at: https://docs.symmetry.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Platform and language support
> Supported operating systems, architectures, languages, and sizing guidance for the On-Premise STE.
This page covers the operating systems, architectures, and languages supported by the locally installed on-premise version of the Symmetry Tax Engine (STE), along with sizing guidance. (The [hosted API](/ste/overview/hosted-vs-on-premise) has no local requirements — you only need an HTTPS client.)
## Supported languages
The on-premise SDK ships with native interfaces for:
* **C / C++**
* **Java**
* **.NET**
**Java** requires a Java Development Kit (JDK), **version 11 or later**.
The Windows distributions also include a **Delphi / Pascal** interface unit (`ste-interface-files/delphi/STE.pas`). It is source only — you compile it into your own project — and it is not part of the Linux or macOS distributions.
For .NET, the distribution includes interface assemblies for more than one target so you can match your existing runtime. Every one of them is named `ste-net-core.dll`; they differ only in which folder under `ste-interface-files` they sit in.
| Target | Folder | Ships on | Status |
| --------------------- | --------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **.NET 8** | `dotnet 8.0` | All platforms | **Current — recommended for new development.** |
| **.NET Standard 2.0** | `dotnet standard 2.0` | All platforms | Supported and widely used. Loadable from .NET Framework 4.7.2+, .NET Core 2.0+, and .NET 5 and later. Also works on .NET Framework 4.6.1–4.7.1, though those versions may need binding redirects and a `System.ValueTuple` reference. |
| **.NET Standard 1.1** | `dotnet standard 1.1` | Linux and macOS | Legacy. Superseded by .NET Standard 2.0. |
Between .NET 8 and .NET Standard 2.0 you can reach .NET Framework 4.6.1 and later, .NET Core 2.0 and later, and every version of .NET from 5 onward — which is to say every .NET runtime Microsoft still supports.
If you target .NET Framework, reference `ste-interface-files/dotnet standard 2.0/ste-net-core.dll`. You do not need to migrate to .NET 8 to stay current.
For new .NET integrations, target **.NET 8**. The .NET Standard assemblies are there for existing integrations.
There is no longer a .NET Framework assembly (`ste-net.dll`). It shipped only in the retired Visual Studio 2010 and 2013 Windows artifacts, whose final release was 2026.8.1. If your integration still references `ste-net.dll`, switch the reference to `ste-interface-files/dotnet standard 2.0/ste-net-core.dll` — see [Migrating STE Windows legacy MSVCRT artifacts to UCRT](/ste/migration/msvcrt-to-ucrt).
.NET Framework 4.6.0 and earlier, and .NET Core 1.x, are no longer reachable. Those runtimes are all past Microsoft's own end of support.
Each language has its own quickstart:
## Operating systems and architectures
The On-Premise STE runs on **Windows**, **Linux**, and **macOS**. Which architectures are available depends on the platform:
| Platform | Architectures |
| ----------- | ------------------------------------------------------------------ |
| **Windows** | x64 (AMD64) and 32-bit x86 |
| **Linux** | x64 (AMD64) and ARM64 |
| **macOS** | Apple Silicon (ARM64) and Intel (x64), in a single universal build |
There is no Windows ARM64 build.
The engine's shared library must be on your application's library search path. A download unzips into a single flat directory — your **STE directory** — with the shared library, the tax database, and the `ste-interface-files` folder all at the top level.
Append your STE directory to the system `Path` environment variable (under **Advanced System Settings > Environment Variables > System Variables**), or copy `ste.dll` directly into your project's build output. If you use the Java interface, copy `jnidispatch.dll` alongside it.
Windows artifacts get the C standard library from the Universal C Runtime, which is built into Windows 10 and later. They also need `VCRUNTIME140.dll`, `MSVCP140.dll`, and on x64 `VCRUNTIME140_1.dll`, which come from the [Visual C++ Redistributable](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170) — install the latest. Windows does not provide those three files, and the STE package does not include them.
Your compiler version need not match the one used to build the engine. See [Linking the native library](/ste/operations/linking-the-native-library#the-windows-c-runtime).
Both **64-bit** and **32-bit** builds are available. When targeting .NET Framework 4.5 or higher with the 64-bit engine, make sure **Prefer 32-bit** is unchecked in your project's build settings.
Add your STE directory to the `LD_LIBRARY_PATH` environment variable, or copy `libste.so` into a directory already on the loader's path, such as `/usr/local/lib`.
The engine ships as a universal shared library that runs on both Apple Silicon (ARM64) and Intel (x64) Macs. Add your STE directory to `DYLD_LIBRARY_PATH`, or copy `libste.dylib` into your build output.
Regardless of platform, your STE directory holds the engine library, the tax database (`ste.db`), `ste.conf`, `versions.json`, a `log` directory, and an `ste-interface-files` folder containing the C header, the Java JAR, the .NET assemblies, and the JSON/XML schemas.
Each package also ships the JNA dispatch library next to the engine — `jnidispatch.dll` on Windows, `libjnidispatch.so` on Linux, `libjnidispatch.jnilib` on macOS. The Java interface needs it, so keep it alongside the engine library wherever you put that.
Licensing is by key. Set the `STE_LICENSE_KEY` environment variable, or place your `ste-license.dat` file in your STE directory — the engine checks the environment variable first.
## Footprint and sizing
The On-Premise STE is deliberately lightweight. The engine is written in C and uses SQLite and Lua, so it runs tax calculations in milliseconds with a small on-disk footprint.
### Application footprint
The installed engine is compact. On Win64, for example:
* Tax database (`ste.db`): about **31 MB**
* Engine library (`ste.dll`): about **4 MB**
A full Win64 installation — the database, the engine, and every interface file — unpacks to just under **40 MB**, from an **11 MB** download. The tax database dominates, and it grows a little with each release as new tax years and jurisdictions are added. A macOS installation runs larger, around **50 MB**, because the shared library is universal and carries code for both architectures.
### Sizing your environment
Symmetry does not publish fixed CPU, memory, or disk requirements for the On-Premise STE. Because the engine is so lightweight, hardware is rarely the constraint — appropriate sizing depends on your own workload (how many pay calculations you run in parallel and how you architect your application) far more than on the engine itself.
Size your machine (or machines, in an n-tier architecture) for the amount of parallel processing your workload requires. If you'd like guidance for a specific deployment, [contact Symmetry](https://support.symmetry.com/hc/en-us/requests/new).
### Concurrency and scaling
The STE is built for high-volume, parallel payroll. In a multi-threaded environment, multiple engine instances can be checked out of a built-in pool, used, and returned for reuse by other threads without re-initializing. Initialization takes only milliseconds, but across thousands or tens of thousands of pay calculations that savings adds up.