TexturePacker CI installation

We introduced the floating license model, also known as the Docker/CI license, in 2020. This permits the use of TexturePacker in a Continuous Integration (CI) system on a server or build machine. It also allows users to run it inside a Docker (or similar) container.

Single User Licenses and Volume Licenses for TexturePacker are designed to be used by 'real' users on a desktop or laptop. These licenses do not permit use on a server or in automated builds.

1. Get your Docker/CI license

First, you have to purchase a Docker/CI license. Here are some things you should consider before the purchase:

Concurrency Level

The concurrency level describes how many instances of TexturePacker you want to run in parallel. It does not matter on how many computers it is running. E.g. you can run all instances on the same computer or distribute them if you have multiple build machines.

During the checkout, you have to decide which concurrency level you need. You can increase the level at any time later from within the License Manager (opens in a new tab).

License Restrictions

1. The license only works from the command line - use it on your build machines only. It is not meant for desktop use.
2. A single license can only run on the same type of operating system - Linux is the default. Please email us to transfer the license to Windows or macOS.

Get the license

The license is available from here: Docker/CI license.

2. Upgrading TexturePacker

The license permits you to always run the newest version of TexturePacker. You must use at least TexturePacker 7.0.3 - older versions have a bug that can cause issues with license release in certain cases.

We've also changed what happens when no activation is available. Versions prior to 7.0.3 return an error in this case, making it difficult to add TexturePacker to a Makefile. The newer versions wait until a seat becomes available and thus do not interrupt the build process.

Activating Docker/CI licenses has also been made easier - see below.

After installation, run TexturePacker from the command line and agree to the license terms. You can also agree to the terms via the UI.

To use the license inside a Docker container, see Docker installation below.

3. Using the License in Your Build

Using the TP_FLOATING_LICENSE environment variable

The easiest way to use the license is to set an environment variable that contains the license key. This allows you to keep your build scripts free from the license key and does not require any modifications.

export TP_FLOATING_LICENSE="TP-????-????-????-????"

Windows (cmd)

set TP_FLOATING_LICENSE=TP-????-????-????-????

Windows (PowerShell)

$env:TP_FLOATING_LICENSE="TP-????-????-????-????"

Using --activate-license

You can also set the Docker/CI license using --activate-license from the command line. Since TexturePacker allocates and deallocates the license with each start, you have to pass it to every call of TexturePacker.

TexturePacker --activate-license TP-????-????-????-???? --sheet sheet.png --data sheet.json .....

This method might be more cumbersome than using the environment variable, as it requires updates to your build scripts.

4. Start your Build

That's all - your build should now work as it did before. Consider increasing the concurrency level for your TexturePacker Docker/CI license if you have a powerful machine with many CPU cores and RAM. This will allow more parallel running instances.

In rare cases, a license might not be properly released - e.g. if TexturePacker is killed without allowing it to release the license. This is no big problem because the activations are released by the server after 2 minutes automatically.

If licenses get often stuck, please make sure that you are using TexturePacker 7.0.3 or newer.

5. Conclusion

Migrating from a Single User or Volume License to a Docker/CI license is easy. If you encounter any issues or have questions, don't hesitate to contact us for support.

Optional: Docker installation

Installing TexturePacker inside Docker is not hard to accomplish. Follow these steps for a simple setup:

1. Create a Dockerfile

This Dockerfile uses Ubuntu 24.04 LTS (22.04 or newer works), pulls the current Ubuntu build of TexturePacker straight from our version-less download URL and installs all required files. There is nothing to download by hand and nothing to keep up to date.

FROM ubuntu:24.04

ARG DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y --no-install-recommends \
    libfontconfig \
    libx11-6 \
    libxkbcommon-x11-0 \
    libglib2.0-0 \
    libdbus-1-3 \
    libgssapi-krb5-2 \
    libgl1 \
    libegl1 \
    libegl-mesa0 \
    && rm -rf /var/lib/apt/lists/*

# Install TexturePacker
ADD https://www.codeandweb.com/download/texturepacker/latest/linux-deb /tmp/TexturePacker.deb
RUN apt-get update && apt-get install -y --no-install-recommends /tmp/TexturePacker.deb \
    && rm -rf /var/lib/apt/lists/* /tmp/TexturePacker.deb

# Uncomment this line if you agree to the license terms
# RUN echo agree | TexturePacker --version

ADD rather than RUN curl: Docker caches a RUN line by its text alone, and the text of a version-less URL never changes, so a RUN curl layer would keep installing the build it downloaded the first time. See Docker caches the layer, not the answer for how to force a rebuild to pick up a new release.

Rebuilding this image gives you whatever the newest release is by then, as long as the ADD layer is not served from the cache (see above). Your Docker/CI license permits exactly that. A Single User or Volume license does not permit automated builds at all, and it only covers releases published inside its update window, so a rebuild can hand you one it does not cover. See what a license covers.

2. Build the image

Build the image and install TexturePacker

docker build -t texturepacker:latest .

Run TexturePacker to read the license agreement.

docker run texturepacker:latest TexturePacker

If you agree with the license terms, uncomment the last line in the Dockerfile. This saves your agreement in the image. TexturePacker won't ask you again to agree when you use this image.

docker build -t texturepacker:latest .

Running TexturePacker inside the Container

A Docker/CI license is a floating license that claims a "seat" when TexturePacker is started and automatically releases the license after the packing process. This is why every run of TexturePacker needs the license: pass it in the TP_FLOATING_LICENSE environment variable, or with --activate-license on the command line.

Use a bind-mount to mount your sprite sheet directories and run the packing process. -e TP_FLOATING_LICENSE forwards the variable from your host, so export it there first (see above):

docker run --rm \
  --mount type=bind,source=/tmp/spritesheets,target=/spritesheets \
  -e TP_FLOATING_LICENSE \
  texturepacker:latest \
  sh -c 'TexturePacker /spritesheets/*.tps'