Today we are proud to announce the release of our Private NuGet Feed. Installing a licensed TX Text Control package now works exactly like installing any NuGet package.

Start building in three simple steps:

1. Download your custom nuget.config file
2. Execute dotnet add package <package>
3. Build and run your application

Your license is automatically embedded in every download. There are no activation dialogs, no license file management, and no additional configuration steps. The package arrives ready to use.

Why we built this

We listened to our customers. The legacy workflow of downloading SDKs, locating license files, and manually configuring each project created unnecessary friction. Development teams told us they wanted the same seamless experience they have with public NuGet packages.

The private NuGet feed delivers exactly that:

Traditional Approach	With the NuGet Feed
Download SDK manually	dotnet add package <package>
Configure each project separately	Works everywhere NuGet works
Manage multiple license files	One API token, all your packages
Hope you have the right version	Only see versions you're licensed for

The result is that you go from zero to building in under two minutes.

How it works

Authentication uses the assigned developer's email address and an API token. The assigned developer's email connects to all serials assigned to them, aggregating access across their entire license portfolio. For example, a developer with both a TX Text Control .NET Server license and a TX Text Control .NET for WPF license sees all applicable packages in a single feed.

There are two ways to generate API tokens for your developers.

Option 1: Automatic token creation

The easiest way to get your developers started is to simply assign a serial number to them. When you assign a NuGet-eligible serial to a developer, the system automatically generates an API token and sends it directly to their email address.

1. In your account, navigate to Manage Products.
2. Click on Manage ​ Assign next to the serial number you want to assign.
3. Enter the developer's email address.
4. Click on Assign to complete the assignment.
5. The developer receives an email containing both the serial number assignment and a download link for their personalized NuGet configuration file.
   The token is valid for 365 days and is automatically extended each time you assign or reassign a serial.

This approach requires no additional steps. Your developer receives everything they need in a single email.

Reassigning a serial to the same or a different developer follows the same process. If the developer already has a valid token, its expiry is automatically extended. If the token has expired or does not exist, a new one is created.

When you unassign a serial from a developer, the system checks whether they have any other NuGet-eligible serials assigned to them. If not, their API token is automatically deleted.

To help you track which developers have active tokens, the Manage Products page provides a visual indicator. Email addresses associated with a NuGet API token are marked with :

Clicking on navigates directly to the Manage API Tokens page, where you can view, delete, and manage all API tokens in your account.

Option 2: Manual token creation

If you need more control over token names or expiry dates, or if you want to create a token for a developer who already has assigned serials, you can create tokens manually:

1. In your account, navigate to Manage API tokens.
2. Click on Create token.
3. Enter a name for the API token.
   If you cannot think of a name, click on Generate to create a random one.
4. Enter the number of days for which the API token is valid.
   The minimum is 1 day and the maximum is 730 days (2 years).
5. Select the email address of the developer for whom you wish to issue an API token.
   Only the email addresses that you have used to assign serial numbers to your developers appear in this list.
6. Click on Create token again.
7. Upon submission, an API token and a corresponding NuGet configuration file are generated. This file contains sensitive credentials and is not displayed. A download link is sent to the assigned developer via email.
   The confirmation screen displays the token name and token prefix for your reference.
8. Finally, click on Proceed to return to the API token management screen (see below).

Installing TX Text Control NuGet Packages in Visual Studio

Follow these instructions to install TX Text Control NuGet packages in different versions of Visual Studio.

Visual Studio 2022

1. Copy the nuget.config file you downloaded to the root folder of your project.
2. Open NuGet Package Manager:
   • Go to Manage NuGet Packages... from the Project main menu.
3. Select the TextControl feed:
   • In the Package source dropdown, select TextControl, Browse and install packages as needed.

Visual Studio 2026 (alternative method, if config file is not recognized)

If Visual Studio doesn't automatically recognize the nuget.config file in your project folder:

1. Open NuGet Configuration:
   • Go to Tools ​ NuGet Package Manager ​ Package Manager Settings
2. Access Configuration Files:
   • In Package Manager Settings,
     go to Configuration Files ​ Select the NuGet.Config file path ​ Open
   • Replace the content with your downloaded nuget.config file.
   • Save and close.
3. Select the TextControl feed:
   • Go to Manage NuGet Packages... from the Project main menu.
   • Select TextControl from the package source dropdown.
   • Browse and install packages.

Discover and install packages

Once configured, assigned developers can search for packages directly from the command line:

dotnet package search "TXTextControl" --source TextControl

The search results show only packages the assigned developer is authorized to access.
This is by design, so there is no confusion about what they may use.

For example, if you assigned your developer TX Text Control .NET Server and TX Text Control .NET for WPF, they will see only:

****************************************
Source: TextControl (https://www.textcontrol.com/nuget/v3/index.json)
| Package ID                               | Latest Version | Owners        | Total Downloads |
| ---------------------------------------- | -------------- | ------------- | --------------- |
| TXTextControl.TextControl.ASP.SDK        | 34.0.1         | txtextcontrol | 1,255           |
| ---------------------------------------- | -------------- | ------------- | --------------- |
| TXTextControl.TextControl.Core.SDK       | 34.0.1         | txtextcontrol | 426             |
| ---------------------------------------- | -------------- | ------------- | --------------- |
| TXTextControl.TextControl.WPF.SDK        | 34.0.1         | txtextcontrol | 225             |
| ---------------------------------------- | -------------- | ------------- | --------------- |
| TXTextControl.Web                        | 34.1.0         | txtextcontrol | 36              |
| ---------------------------------------- | -------------- | ------------- | --------------- |
| TXTextControl.Web.DocumentViewer         | 34.1.0         | txtextcontrol | 31              |
| ---------------------------------------- | -------------- | ------------- | --------------- |
| TXTextControl.Web.DocumentViewer.Classic | 34.0.0         | txtextcontrol | 28              |
| ---------------------------------------- | -------------- | ------------- | --------------- |
| TXTextControl.Web.DocumentEditor.Backend | 34.1.0         | txtextcontrol | 23              |
| ---------------------------------------- | -------------- | ------------- | --------------- |

Notice that TXTextControl.TextControl.WinForms.SDK does not appear in the results.

Install a package with a single command:

dotnet add package TXTextControl.TextControl.ASP.SDK --version 34.0.1

When the package installs, NuGet retrieves it from the private feed using the credentials in nuget.config. Server-side, the license is automatically injected into the package before download. Once the package has been downloaded, it is ready to use immediately.

Available packages

The following packages are available through the private NuGet feed:

Package	Description
TXTextControl.TextControl.ASP.SDK	This NuGet package includes the required files to develop a .NET 8.0 or higher ASP.NET application with TX Text Control 34.0.
TXTextControl.TextControl.Core.SDK	This NuGet package includes the required files to develop a .NET 8.0 or higher .NET and ASP.NET Core application with TX Text Control 34.0.
TXTextControl.Web.DocumentEditor.Backend	This package contains the backend components of the TX Text Control Document Editor and a hosted worker service for easily starting the Document Editor backend from ASP.NET Core applications.
TXTextControl.Web	This NuGet package contains the necessary files for creating an ASP.NET (Core) web application that supports the TX Text Control online document editor.
TXTextControl.Web.DocumentViewer	This NuGet package contains the necessary files for creating an ASP.NET (Core) web application that supports the TX Text Control document viewer using the Core version of TX Text Control.
TXTextControl.Web.DocumentViewer.Classic	This NuGet package includes the required files to create an ASP.NET (Core) web application with support for the TX Text Control document viewer using the Classic version of TX Text Control.
TXTextControl.TextControl.WinForms.SDK	This NuGet package includes the required files to develop a .NET 8.0 or higher Windows Forms application with TX Text Control 34.0.
TXTextControl.TextControl.WPF.SDK	This NuGet package includes the required files to develop a .NET 8.0 or higher WPF application with TX Text Control 34.0.

NuGet Packages for Windows Forms and WPF: Build-Time Only Usage

The NuGet packages for Windows Forms and WPF are intended for compilation purposes only, such as use on build servers or within CI/CD pipelines. While they enable projects to compile successfully, they do not include design-time components. In order to create new applications or work with Visual Studio designers, the complete Text Control setup must be installed on the development machine.

CI/CD integration

The NuGet feed integrates seamlessly into automated build pipelines. The key is to store credentials as secrets in your CI/CD platform and generate the nuget.config file dynamically during the build process. This approach keeps sensitive credentials out of source control while enabling fully automated builds.

GitHub Actions

GitHub Actions is widely adopted for .NET projects, especially for open-source development and modern cloud-native applications. To configure the Text Control NuGet feed, add your credentials as repository secrets:

1. Navigate to your repository on GitHub.
2. Go to Settings ​ Secrets and variables ​ Actions.
3. Click on New repository secret and add:
   • TEXTCONTROL_EMAIL ​ The assigned developer's email address.
   • TEXTCONTROL_API_TOKEN ​ The API token generated for that developer.

In your workflow file, generate the nuget.config before restoring packages:

name: Build

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '8.0.x'

      - name: Create nuget.config
        run: |
          cat > nuget.config << 'EOF'
          <?xml version="1.0" encoding="utf-8"?>
          <configuration>
            <packageSources>
              <clear />
              <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
              <add key="TextControl" value="${{ secrets.TEXTCONTROL_FEED_URL }}" />
            </packageSources>
            <packageSourceCredentials>
              <TextControl>
                <add key="Username" value="${{ secrets.TEXTCONTROL_EMAIL }}" />
                <add key="ClearTextPassword" value="${{ secrets.TEXTCONTROL_API_TOKEN }}" />
              </TextControl>
            </packageSourceCredentials>
          </configuration>
          EOF

      - name: Restore dependencies
        run: dotnet restore

      - name: Build
        run: dotnet build --no-restore --configuration Release

      - name: Test
        run: dotnet test --no-build --configuration Release

The nuget.config file is generated at runtime using secrets, ensuring credentials never appear in your repository history. The workflow supports both push events and pull requests, enabling continuous integration for all branches.

GitLab CI/CD

GitLab CI/CD is popular among teams that prefer an all-in-one DevOps platform. Store your credentials as CI/CD variables in your project settings:

1. Navigate to Settings ​ CI/CD ​ Variables.
2. Add TEXTCONTROL_EMAIL and TEXTCONTROL_API_TOKEN (mark as masked and protected).

Configure your .gitlab-ci.yml:

stages:
  - build
  - test

variables:
  DOTNET_VERSION: '8.0'

build:
  stage: build
  image: mcr.microsoft.com/dotnet/sdk:8.0
  before_script:
    - |
      cat > nuget.config << EOF
      <?xml version="1.0" encoding="utf-8"?>
      <configuration>
        <packageSources>
          <clear />
          <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
          <add key="TextControl" value="${TEXTCONTROL_FEED_URL}" />
        </packageSources>
        <packageSourceCredentials>
          <TextControl>
            <add key="Username" value="${TEXTCONTROL_EMAIL}" />
            <add key="ClearTextPassword" value="${TEXTCONTROL_API_TOKEN}" />
          </TextControl>
        </packageSourceCredentials>
      </configuration>
      EOF
  script:
    - dotnet restore
    - dotnet build --configuration Release --no-restore
  artifacts:
    paths:
      - '**/bin/Release/'

test:
  stage: test
  image: mcr.microsoft.com/dotnet/sdk:8.0
  needs:
    - build
  script:
    - dotnet test --configuration Release --no-build

Azure DevOps

Azure DevOps is the CI/CD platform of choice for many enterprise .NET teams, particularly those already invested in the Microsoft ecosystem. Azure Pipelines provides native support for NuGet feeds and integrates tightly with Azure Artifacts.

To configure credentials securely, create a variable group in your Azure DevOps project:

1. Navigate to Pipelines ​ Library.
2. Click on + Variable group.
3. Name the group (e.g., TextControl-NuGet).
4. Add the following variables:
   • TEXTCONTROL_EMAIL ​ The assigned developer's email address.
   • TEXTCONTROL_API_TOKEN ​ The API token (mark as secret).
5. Save the variable group.

Reference the variable group in your azure-pipelines.yml:

trigger:
  - main
  - develop

pool:
  vmImage: 'ubuntu-latest'

variables:
  - group: TextControl-NuGet
  - name: buildConfiguration
    value: 'Release'

steps:
  - task: UseDotNet@2
    displayName: 'Setup .NET SDK'
    inputs:
      version: '8.0.x'
      includePreviewVersions: false

  - script: |
      cat > nuget.config << 'EOF'
      <?xml version="1.0" encoding="utf-8"?>
      <configuration>
        <packageSources>
          <clear />
          <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
          <add key="TextControl" value="$(TEXTCONTROL_FEED_URL)" />
        </packageSources>
        <packageSourceCredentials>
          <TextControl>
            <add key="Username" value="$(TEXTCONTROL_EMAIL)" />
            <add key="ClearTextPassword" value="$(TEXTCONTROL_API_TOKEN)" />
          </TextControl>
        </packageSourceCredentials>
      </configuration>
      EOF
    displayName: 'Create nuget.config'

  - task: DotNetCoreCLI@2
    displayName: 'Restore packages'
    inputs:
      command: 'restore'
      projects: '**/*.csproj'

  - task: DotNetCoreCLI@2
    displayName: 'Build solution'
    inputs:
      command: 'build'
      projects: '**/*.csproj'
      arguments: '--configuration $(buildConfiguration) --no-restore'

  - task: DotNetCoreCLI@2
    displayName: 'Run tests'
    inputs:
      command: 'test'
      projects: '**/*Tests.csproj'
      arguments: '--configuration $(buildConfiguration) --no-build'

For teams using the classic editor instead of YAML pipelines, the same approach works. Add a Command line task to generate the nuget.config file before the NuGet restore task, referencing variables from your variable group.

Azure DevOps also supports service connections for authenticated feeds. However, generating the nuget.config dynamically provides more flexibility and works consistently across self-hosted and Microsoft-hosted agents.

Get started today

The Text Control private NuGet feed is available now for all customers with active licenses. Sign in to your account, generate an API token, and let your developers experience the new streamlined workflow for themselves.

We built this feed because we believe your developers' time is better spent building great applications than managing license files. With automatic license injection, seamless CI/CD integration, and support for every major build platform, the private NuGet feed removes the friction between your developers and your next release.

No more manual downloads. No more license file headaches.

Just dotnet add package <package> and start building.

We are excited to see what your developers create. Happy coding!