# Linux Requirements

> Check a Linux server or container for TX Text Control .NET Server: x64 and glibc 2.34, the .NET runtime, gconv and ICU, fonts, files, ports and processes.

- **Product:** TX Text Control .NET Server
- **Section:** Documentation
- **Kind:** Topic
- **Path:** TX Text Control .NET Server > Deployment Guide > Linux > Linux Requirements
- **2221 words**
- **Web URL:** https://docs.textcontrol.com/tx-text-control-dotnet-server/deployment/linux/requirements/
- **LLMs URL:** https://docs.textcontrol.com/tx-text-control-dotnet-server/deployment/linux/requirements/llms.txt
- **LLMs-Full URL:** https://docs.textcontrol.com/tx-text-control-dotnet-server/deployment/linux/requirements/llms-full.txt

---

A Linux server or container runs TX Text Control .NET Server when it offers what the Core engine's native libraries and the Document Editor backend expect: an x64 processor, the GNU C Library, the .NET runtime and a few system files that minimal images leave out. The tables and sections below list these requirements for administrators and developers who choose a distribution or a base image, or who look for the cause when something fails on Linux only.

The requirements apply to the Core engine in `TXTextControl.TextControl.Core.SDK`, the only engine that runs on Linux.

### At a Glance

| Requirement | Linux |
|---|---|
| Engine | Core (`TXTextControl.TextControl.Core.SDK`) |
| Processor architecture | x64, runtime identifier `linux-x64`; 64-bit process |
| C library | GNU C Library (glibc) 2.34 or later; musl, as in Alpine Linux, doesn't work |
| C++ runtime | `libstdc++` with the symbol version `GLIBCXX_3.4.29` (GCC 11) or later |
| .NET | ASP.NET Core Runtime 8.0 or later, with the `dotnet` command available |
| System files | glibc's gconv modules; ICU unless the application runs in globalization-invariant mode |
| Fonts | None on the system; the application brings a *Fonts* folder |
| Network | The HTTP port of your application; TCP port 4283 of the Document Editor backend, used only by your application |

### Distributions

Which distributions Text Control lists as tested and supported is described in [Operating Systems](https://docs.textcontrol.com/tx-text-control-dotnet-server/installation/requirements/operating-systems/#deployment). The distributions must meet the requirements on this page.

An ASP.NET Core application with the version 34.0 packages has been run on the following systems:

| System | glibc | Result |
|---|---|---|
| Ubuntu 24.04 LTS, image `mcr.microsoft.com/dotnet/aspnet:10.0` | 2.39 | Document processing, Document Editor and Document Viewer work |
| Ubuntu 24.04 chiseled, image `mcr.microsoft.com/dotnet/aspnet:10.0-noble-chiseled` | 2.39 | Works after the gconv modules are added |
| Debian 12 | 2.36 | Document processing and Document Editor work |
| Debian 13 | 2.41 | Document processing, Document Editor and Document Viewer work |
| Alpine Linux, image `mcr.microsoft.com/dotnet/aspnet:10.0-alpine` | musl | The application process ends when a document is created |

The .NET runtime has its own list of supported distributions and versions; [.NET Versions](https://docs.textcontrol.com/tx-text-control-dotnet-server/installation/requirements/dotnet/llms-full.txt) describes the versions TX Text Control supports.

### Processor Architecture and C Library

The Core package contains native Linux libraries only for the runtime identifier `linux-x64`, 14 shared objects such as *tx34core.so*, *tx34\_pdf.so* and *txfntmgr.so*. There are no libraries for `linux-arm64` or `linux-musl-x64`, so ARM64 servers and Alpine Linux can't run TX Text Control. The Document Editor backend also refuses to start in a 32-bit process.

The native libraries link only against the GNU C Library, `libstdc++` and `libgcc_s`. Their highest required symbol versions, read from the libraries of version 34.0.5, are `GLIBC_2.34`, `GLIBCXX_3.4.29` and `CXXABI_1.3.9`. Distributions with an older glibc or C++ runtime, such as Debian 11, don't meet them. On Debian and Ubuntu, the packages `libc6`, `libstdc++6` and `libgcc-s1` provide these libraries, and the .NET runtime needs them as well.

The libraries don't link against fontconfig, FreeType, X11, `libgdiplus` or OpenSSL, so none of these has to be installed.

### .NET Runtime

- **The application.** A framework-dependent application needs the ASP.NET Core Runtime of its target framework on the server. The NuGet packages target .NET 8 and work in .NET 8, .NET 9 and .NET 10 projects.
- **The Document Editor backend.** `TXTextControl.Web.Server.Core` is built for .NET 8 and rolls forward to the newest installed major version. A server or image with only the .NET 10 runtime runs it.
- **The `dotnet` command.** The hosted service `DocumentEditorWorkerManager` starts the backend with the `dotnet` command, and the backend starts its worker processes the same way. The command is found next to the running `dotnet` host or on the search path. An application that is started through its own executable, or that is published self-contained, needs `dotnet` on the search path; otherwise it ends at startup with "Error starting TXTextControl.Web.Server.Core: An error occurred trying to start process 'dotnet'".

Applications without the Document Editor, which only process documents or show them in the Document Viewer, start no additional processes.

### System Files

#### gconv Modules

TX Text Control converts character sets with the `iconv` functions of glibc, which load the gconv modules from */usr/lib/x86\_64-linux-gnu/gconv*. Standard installations contain them; on Debian 13, they belong to the package `libc6`.

> Warning
>
> **Chiseled Images.** Ultra-minimal chiseled container images leave the gconv modules out. In such an image, the application process ends without an error message as soon as `ServerTextControl` creates a PDF document, and the Document Editor closes its connection when it exports a PDF document. Copy the gconv folder into the image with a multi-stage build, as the blog article [Using TX Text Control with Ultra-Minimal Chiseled Linux Containers](https://www.textcontrol.com/blog/2025/03/12/using-tx-text-control-with-ultra-minimal-chiseled-linux-containers/) shows. [Dockerfile](https://docs.textcontrol.com/tx-text-control-dotnet-server/deployment/docker/dockerfile/llms-full.txt) describes the image.

#### ICU and Globalization-Invariant Mode

The chiseled image `mcr.microsoft.com/dotnet/aspnet:10.0-noble-chiseled` contains no ICU libraries and runs .NET in globalization-invariant mode with `DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=true`. In this mode, the Document Editor backend logs errors such as "en is an invalid culture identifier." for each editor. The image variant `10.0-noble-chiseled-extra` contains ICU and doesn't set the mode; with the gconv modules added, the editor runs without these errors.

### Fonts

The Core engine doesn't use the fonts installed on the system. The Core package adds a *Fonts* folder to the build and publish output, and the engine loads its fonts from the *Fonts* folder in the application's base directory, whatever the working directory is. Deploy the folder with the application, and add company fonts to it. [Fonts](https://docs.textcontrol.com/tx-text-control-dotnet-server/deployment/docker/fonts/llms-full.txt) describes custom fonts in containers.

### Files and Permissions

- **Read access to the application folder.** It contains the assemblies, the native libraries, the *Fonts* folder and the files of the Document Editor backend.
- **The configuration file of the backend.** The backend reads *TXTextControl.Web.Server.Core.config.json* from its own folder, in exactly this spelling; Linux file names are case-sensitive.
- **Backend logs.** The configuration file in the package sets `LogTarget` to `Console`, so the backend's messages go to the logging of your application and nothing is written to disk. Without the file, or with a `Logging` section that has no `LogTarget`, the backend writes log files to the folder in `FolderPath`, by default *./logs* relative to the working directory, and the user running the application needs write access there.
- **appsettings.json.** ASP.NET Core reads it from the content root, which is the working directory. Set the working directory of a service to the application folder, or the application doesn't find the file.

### Network Ports

| Port | Used by | Reachable from |
|---|---|---|
| The HTTP port of your application, for example 5000 behind nginx or 8080 in a container | Browsers, through a reverse proxy or load balancer | The proxy or the network of your users |
| TCP 4283, the default port of the Document Editor backend | The WebSocket middleware of your application | Your application only |

Without configuration, the backend listens on port 4283 on all network interfaces, for IPv4 and IPv6. Bind it to the loopback address with `DocumentEditorWorkerOptions` when it runs on the same machine, as [Ubuntu](https://docs.textcontrol.com/tx-text-control-dotnet-server/deployment/linux/ubuntu/#prepare-the-application) shows, or restrict the port with the firewall. In the backend's configuration file, `TcpPort` sets the port and `SupportedIpVersions` sets `IPv4`, `IPv6` or `Both`; the backend ignores keys with a different spelling, such as `SupportedIPVersions`. The backend and its worker processes communicate over pipes and need no further ports.

### Processes

An application with the Document Editor runs these processes on Linux:

| Process | Started by | Count |
|---|---|---|
| Your application, for example `dotnet MyApp.dll` | systemd, the container runtime or you | 1 |
| `dotnet TXTextControl.Web.Server.Core.dll` | `DocumentEditorWorkerManager` in your application | 1 per application process |
| `dotnet TXTextControl.Web.Server.Core.Process.dll` | The backend | 1 per connected editor, plus short-lived processes for ribbon content |

When your application shuts down, it stops the backend and all of its worker processes. Each open editor needs memory on the backend; [Document Editor Architecture](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-editor/architecture/#scaling-and-load-balancing) gives Text Control's sizing guidance.

### Not Available on Linux

- **The Classic engine.** `TXTextControl.TextControl.ASP.SDK` and `TXTextControl.Web.DocumentViewer.Classic` run on Windows only.
- **The DOC format.** The Core engine doesn't load or save the legacy Word binary format, on any operating system. See [Supported File Formats](https://docs.textcontrol.com/tx-text-control-dotnet-server/overview/file-formats/llms-full.txt).
- **The trial setup.** The setup that installs the trial version is a Windows installer.

### Related Pages

- [Ubuntu](https://docs.textcontrol.com/tx-text-control-dotnet-server/deployment/linux/ubuntu/llms-full.txt) — deploy an application to Ubuntu with systemd and nginx.
- [Debian](https://docs.textcontrol.com/tx-text-control-dotnet-server/deployment/linux/debian/llms-full.txt) — the same deployment on Debian.
- [Dockerfile](https://docs.textcontrol.com/tx-text-control-dotnet-server/deployment/docker/dockerfile/llms-full.txt) — build a container image, including chiseled images.
- [Operating Systems](https://docs.textcontrol.com/tx-text-control-dotnet-server/installation/requirements/operating-systems/llms-full.txt) — Windows and Linux for development and deployment.
- [Troubleshooting Linux](https://docs.textcontrol.com/tx-text-control-dotnet-server/troubleshooting/linux/llms-full.txt) — solve problems that occur on Linux.

---

## Nearby

- **Previous:** [Debian](https://docs.textcontrol.com/tx-text-control-dotnet-server/deployment/linux/debian/llms-full.txt)
- **Next:** [Docker](https://docs.textcontrol.com/tx-text-control-dotnet-server/deployment/docker/llms-full.txt)