﻿---
title: Licensing
description: The Standard license and the Developer license side by side, their free trials, how to buy, activate and move them in the Blender and Maya plugins and the C, Rust and Python SDKs, and the third-party software Deformable uses.
url: https://help.tangerina.io/deformable/v0.2.1/licensing/
---

# Licensing – Deformable v0.2.1

Deformable has two licenses. The Standard license is for one person on one computer, in the Blender plugin, the Maya
plugin and the C, Rust and Python SDKs. The Developer license is for one company that ships the engine inside one
application, built with the C, Rust or Python SDK, to any number of users. Each one starts with a free trial. The
license check lives in the engine library that the plugins and every SDK load, and one activate call takes either
kind of key.

## Two licenses

| | Standard license | Developer license |
|---|---|---|
| Who | 1 person, 1 computer (1 seat) | 1 company, 1 application, any number of end users |
| Works in | The Blender plugin, the Maya plugin and the C, Rust and Python SDKs | The C, Rust and Python SDKs only. The Blender and Maya plugins refuse it. |
| Trial | The Standard trial: free, 7 days, no key. It starts online by itself, with up to 2,500 tetrahedrons per scene. | The Developer trial: a free 30-day trial key that we email you when you ask. It works offline, with no tetrahedron limit. |
| Price | $99 one time (USD), on the payment page | [Contact us](mailto:support@tangerina.io) |
| Key | `TGDF-XXXX-XXXX-XXXX` | `TGDF-<payload>.<signature>`: the `.` tells the two apart |
| Turn it on | Activate the key once, online. It renews by itself at least once every 7 days of use, and stays on the computer. | Your application activates the key at every start, offline. Nothing is stored on the computer. |
| Limit | None | None |
| Status line | **Standard license** | **Developer license:** followed by your company's name |
| Updates | Every future version | Every future version |
| Support | Email | Email |
| Refund | Within 14 days of purchase | None once the full key is sent. Try it first with the 30-day trial key. |
| End users | — | Need nothing: no activation, no network, no seat and no end date |

To use Deformable yourself, in a plugin or in your own scripts and programs, take the Standard license. To ship the
engine inside an application you give to others, take the Developer license. Both include every future version and
email support at [support@tangerina.io](mailto:support@tangerina.io).

## Standard license

The Standard license covers the Blender plugin, the Maya plugin and the C, Rust and Python SDKs on one computer. One
license covers the Blender and Maya plugins: there is no separate license for Maya. It is $99 one time (USD), with no
subscription. It does not expire, and it covers all future versions: every update is included.

In short: download a plugin or an SDK, use the 7-day Standard trial (up to 2,500 tetrahedrons), buy, get the key by
email, activate the key, and use Deformable. It works offline between renewals, which need the internet at least once
every 7 days of use.

![Pay $99, get the license key by email, activate it in the plugin, and the plugin shows Standard license.](https://help.tangerina.io/deformable/v0.2.1/images/license-buy-and-activate.svg)

To download the trial, go to [tangerina.io/deformable](https://tangerina.io/deformable#download). To buy a license, see the
pricing on [tangerina.io/deformable](https://tangerina.io/deformable#pricing).

### One license state per computer

The Standard trial and the Standard license belong to your user account on one computer. The plugins, your Python
scripts and your own programs on that computer all read the same state:

- The trial starts once, in whichever of them you use first.
- A license you activate in one plugin also licenses the other plugin and the SDKs on that computer, and a license
  you activate from an SDK also licenses the plugins.
- Deactivating in one of them deactivates it for all of them.

Another user account on the same computer keeps its own state, so it activates the key again. If that activation
says the license is active on another device, deactivate it in the first account, then activate it in the second.

### Internet access

The Standard license needs the internet once to start the trial and once to activate a license. After that it works
offline, but a license needs a renewal at least once every 7 days of use: whenever Deformable runs on a computer that
is online, it renews the license by itself. A computer that is never online cannot start the Standard trial or keep a
Standard license, so the Standard license does not support computers without internet access. The Developer license
needs no internet at all.

### Standard trial

To download the trial for the Blender plugin or the Maya plugin:

1. Go to [tangerina.io/deformable](https://tangerina.io/deformable#download), on the **Blender plugin** or the
   **Maya plugin** tab.
2. Click **Download for** your system. The page detects your system. If it guessed wrong, or you want the file for
   another computer, pick it under **Other platforms**: macOS Apple silicon, Linux x64 or Windows x64.
   Each `.zip` file works on its own system only.
3. Save the `.zip` file. Keep the Blender plugin's file zipped: Blender installs it as it is. Unzip the Maya plugin's
   file into a Maya modules folder, as its
   [Getting started with Maya](https://help.tangerina.io/deformable/v0.2.1/user-guides/maya/getting-started/) page shows.

The SDKs need no separate trial download. Install one as the [SDKs](#the-sdks) section below shows, and the trial
works the same as in the plugins.

The trial starts the first time Deformable runs on the computer. The computer must be online that one time: the
engine asks our licensing service to start the trial. After that, the trial also works offline.

- **In Blender:** open **Edit > Preferences > Get Extensions > Install from Disk** and choose the `.zip` file. The
  plugin starts the trial and shows **Standard trial: 7 days left**.
- **In Maya:** load the **deformable** plugin in **Windows > Settings/Preferences > Plug-in Manager**. The plugin
  starts the trial, and **Deformable Help > License…** shows **Standard trial: 7 days left**.
- **In an SDK:** the first call that does engine work, such as a mesh tool, adding an object or a simulation step,
  starts the trial. It waits at most 5 seconds for our licensing service. You can also start it yourself with the
  SDK's license refresh call, as in [The SDKs](#the-sdks).

When the computer is offline at that first run, Deformable shows **Go online once to start the Standard trial**, and
nothing runs until it can reach our licensing service once.

During the trial, every feature works. A scene can hold up to 2,500 tetrahedrons, counting every object in it,
floors included, but a disabled one, which takes no part in the simulation. Over the limit, the objects that do not
fit stay still (they are not simulated), and the rest of the scene runs. Adding such an object fails with a message
that says the limit, such as **Trial limit: this would simulate 3,120 tetrahedrons; the trial allows 2,500**. In the
plugins, the object shows that message, and a scene over the limit says how many tetrahedrons it simulates. To stay
under the limit, lower **Target Face Count** on the object's Autocage, use a simpler cage, or simulate fewer objects.
See [Use fewer tetrahedrons](https://help.tangerina.io/deformable/v0.2.1/user-guides/engine/preparing-meshes/#use-fewer-tetrahedrons).

On day 8, Deformable shows **Standard trial ended — Buy license**. The tools and the simulation stop, in the plugins
and in every SDK. Your files stay as they are, and a program can still read and free what it already made.

Reinstalling a plugin or an SDK does not restart the trial: the engine keeps the trial's start in your user folder,
outside the plugins and the SDKs, and a reinstall leaves that folder alone. Our licensing service also keeps the date
the trial started on this computer, which brings that date back even when the folder is gone.

Deformable tells computers apart by the device id the operating system gives. On a computer that gives none, such
as some Linux containers without a machine id, there is no Standard trial, and Deformable shows
**No Standard trial on this device — Buy license**. A Standard license works there as usual.

### Buy a Standard license

1. Click **Buy license** in the Blender plugin's preferences, or **Buy License** in the Maya plugin's **Deformable
   Preferences** window. Your browser opens the pricing on
   [tangerina.io/deformable](https://tangerina.io/deformable#pricing).
2. Click **Buy license** there. Your browser opens the payment page.
3. Pay $99.
4. Our licensing service emails you your license key. It looks like `TGDF-XXXX-XXXX-XXXX`.

The payment is one time, with no subscription. The license does not expire, and it covers all future versions:
every update is included.

### Activate a Standard license

Activate the key in a plugin or from any SDK. One activation is enough for all of them on that computer.

In Blender:

1. Open **Edit > Preferences > Add-ons** and expand **Deformable**.
2. Paste your license key into the **License Key** field.
3. Make sure the computer is online, and click **Activate**. This needs internet one time.
4. The plugin shows **Standard license**. The tetrahedron limit is gone.

In Maya:

1. Choose **Deformable Help > License…**. The **Deformable Preferences** window opens.
2. Paste your license key into the key field of its **License** section.
3. Make sure the computer is online, and click **Activate**. This needs internet one time.
4. The window shows **Standard license**. The tetrahedron limit is gone.

From an SDK, call its activate function once with the key, as in [The SDKs](#the-sdks).

### Daily use and offline use

- Deformable works offline between renewals. A renewal needs the internet at least once every 7 days of use.
- While you use Deformable on a computer that is online, the engine renews the license quietly, a few times a day at
  most. You do not need to do anything. The Blender plugin also checks each time Blender starts, and the Maya plugin
  each time it loads in Maya's window.
- Each renewal lets the license run for about 7 days offline. When Deformable was not used for longer than that, the
  first tool or simulation step renews the license first, waiting a few seconds for our licensing service.
- When the computer stays offline for longer than about 7 days, Deformable shows
  **Go online once to renew the Standard license**, and the tools and the simulation stop until you connect. Connect,
  and it renews the license. A computer that is online while you use Deformable never sees this.
- In Blender, Deformable follows **Allow Online Access** (**Edit > Preferences > System > Network**). While it is
  off, Deformable contacts nothing, the license works only as far as it works offline, and the plugin preferences
  show **Online access is off in Blender's preferences (System > Network)**.
- In Maya, the plugin contacts our licensing service whenever the license needs it. Maya has no setting that turns a
  plugin's internet access off, so the Maya plugin has none either.
- Deformable trusts the computer's clock. If the clock is set back, Deformable shows
  **The clock is behind: set the correct time** and stops until the clock is right again.

### Devices

A Standard license is 1 seat: one computer. A second computer needs the license moved to it, or a second license.
To move it, deactivate it on the old computer first (see below).

To move your license to a new computer:

1. On the old computer, deactivate the license: click **Deactivate** in a plugin's license section, or call
   the SDK's deactivate function. This needs internet. If you no longer have the old computer, remove it in the license
   portal instead. The link is in the FAQ at [tangerina.io/deformable](https://tangerina.io/deformable#faq). A
   computer removed in the portal stops at its next renewal, and within about 7 days if it stays offline.
2. On the new computer, install a plugin or an SDK and activate it with the same key, as in
   [Activate a Standard license](#activate-a-standard-license).

![The same license key moving from the old computer, where it is deactivated first, to the new computer, where it is activated.](https://help.tangerina.io/deformable/v0.2.1/images/license-move-to-new-computer.svg)

### Standard status lines

Each plugin shows the status line, the Blender plugin in its preferences and the Maya plugin in its **Deformable
Preferences** window, and the SDKs give the same text as the license status's message.

| Status | What it means |
|---|---|
| **Standard trial: 7 days left** | The Standard trial runs. The number counts down each day, to **Standard trial: 1 day left**. |
| **Standard trial ended — Buy license** | The 7 days are over. The tools and the simulation stop until you activate a license. |
| **No Standard trial on this device — Buy license** | This computer gives no device id, so it cannot have a Standard trial. A Standard license works. |
| **Standard license** | A Standard license key is active on this computer. There is no limit. |
| **Go online once to start the Standard trial** | The Standard trial has not started yet. Connect to the internet once. |
| **Go online once to renew the Standard license** | The license went about 7 days without a renewal. Connect to the internet once. |
| **The clock is behind: set the correct time** | The computer's clock was set back. Correct it. |

The messages that activating, deactivating and checking can show are in [Status messages](#status-messages).

### Standard refunds

You can ask for a refund within 14 days of purchase: email [support@tangerina.io](mailto:support@tangerina.io)
from the email address you used to buy the license. After a refund, the license stops working: on its computer at
the next renewal, within a day when the computer is online, and within about 7 days when it stays offline.

### Lost Standard license key

1. Open the license portal. The link is in the FAQ at
   [tangerina.io/deformable](https://tangerina.io/deformable#faq).
2. Enter the email address you used to buy the license.
3. Open the login link that the portal sends to that email address.
4. Copy your license key.

If that does not work, email [support@tangerina.io](mailto:support@tangerina.io) from the address you used to buy
the license.

## Developer license

The Developer license lets one company ship the engine inside one application, built with the C, Rust or Python SDK,
to any number of end users. Your application carries the key and turns it on each time it starts, offline. A second
application needs a second Developer license.

The Developer license works in the SDKs only. The Blender and Maya plugins refuse a Developer key with the message
**Developer licenses work in the SDKs only: the plugins need a Standard license**: to use the plugins, take a
Standard license.

In short: write to us, get a 30-day trial key by email, activate it in your application, agree the price with us,
pay the invoice, and get the full key by email.

![Write to us, get a trial key by email, activate it in your application, and the application shows Developer license.](https://help.tangerina.io/deformable/v0.2.1/images/license-developer.svg)

### Developer trial

To try the Developer license, email [support@tangerina.io](mailto:support@tangerina.io) and ask for a trial key, or
click **Ask for a trial key** in the pricing on [tangerina.io/deformable](https://tangerina.io/deformable#pricing).
We email you a trial key that works for 30 days, with every feature and no tetrahedron limit. Use it the way you will
use the full key, as in [Activate a Developer license](#activate-a-developer-license). It works offline: the key
itself holds the day it ends.

The status line counts the days down, from **Developer trial: 30 days left** to **Developer trial: 1 day left**.
When the trial key ends, activating it fails with **Developer trial ended — Contact us**, and a program that is
running stops at that moment too: every call that does engine work fails with the same message. A program can still
read and free what it already made.

The trial key is for testing only: never ship it inside your application. To try for longer, ask us, and we send a
new trial key.

### Buy a Developer license

The Developer license has no public price:

1. Email [support@tangerina.io](mailto:support@tangerina.io), or click **Contact us** in the pricing on
   [tangerina.io/deformable](https://tangerina.io/deformable#pricing). Name your company and the application you
   ship.
2. We agree the price with you by email.
3. Our payment provider sends you an invoice that names your company and your application. Pay it.
4. We email you the full key. It starts with `TGDF-` like the trial key, and it never ends.

The payment is one time, with no subscription. The license does not expire, and it covers all future versions:
every update is included.

### Activate a Developer license

Your application turns the key on itself, with the SDK's activate call: the same call that activates a Standard key.
A key with a `.` in it is a Developer key. The library checks it offline, against the signature it carries, and
never contacts the network, so the call's timeout does not matter. Nothing is stored on the computer: the key holds
for that run of the program only. So:

- Call activate with the key at every start of your application, as its first Deformable call, before status and
  refresh too. A status call made first makes the Standard license's state folder on that computer, and a refresh or
  an engine call made first starts the Standard trial there, online. A program on a Developer license never needs
  refresh.
- Keep the key inside your application, such as in its code, never in a file that its users read or edit, and never
  in a public place such as a public repository.
- To move from the trial key to the full key, put the full key in the trial key's place. A running program keeps the
  first Developer key it activated: activating a different one fails with
  **Another Developer license key is already set in this program**, so the new key counts from the next start.
- Once a Developer key is active, the program refuses a Standard key with **This program uses a Developer license**.

The code for each SDK is in [The SDKs](#the-sdks).

### What end users need

Nothing. On your users' computers, your application needs no activation, no network, no seat and no end date.
Deformable starts no trial there, keeps no license state in their user folder and contacts no licensing service.
The status line shows **Developer license:** followed by your company's name.

The key covers the one application that you named when you bought it. Ship the engine library only inside that
application, keep the key hidden in it, and never pass on the key. Ship the SDK only as the part your application
needs to run, never as a way for others to build their own applications on the engine. The
[Terms of Use](https://tangerina.io/terms-of-use) hold the full terms.

### Developer status lines

Your application reads the status line from the SDK's license status, as its message.

| Status | What it means |
|---|---|
| **Developer trial: 30 days left** | A Developer trial key is active in this program. The number counts down each day, to **Developer trial: 1 day left**. There is no limit. |
| **Developer trial ended — Contact us** | The trial key ended. The engine stops until the program activates a full key, at its next start. |
| **Developer license:** followed by the company's name | A full Developer key is active in this program. There is no limit. A long company name is cut short to fit the line. |

The messages that activating can show are in [Status messages](#status-messages).

### Developer refunds

There is no refund once the full key is sent. Try the license first with the 30-day trial key.

### Lost Developer license key

Email [support@tangerina.io](mailto:support@tangerina.io) from the address you used to buy the license, and we send
the key again.

## Status messages

Activating, deactivating, **Check Now** in the plugins and the SDKs' refresh can also show these messages.

### Standard messages

| Message | What to do |
|---|---|
| **This is not a license key** | Copy the key again from the email. A Standard key looks like `TGDF-XXXX-XXXX-XXXX`. |
| **This license key does not exist** | Check the key for typos, or find it in the license portal (see [Lost Standard license key](#lost-standard-license-key)). |
| **This license key is not a Deformable Standard license** | The key is for another product or plan. Use your Deformable key. |
| **This license is active on another device: deactivate it there or remove that device in the license portal** | See [Devices](#devices). |
| **License key not accepted:** followed by a reason | Our licensing service refused the key for the reason given. Write to [support@tangerina.io](mailto:support@tangerina.io) if it is unclear. |
| **The license was revoked or this device was removed** | A renewal found the license refunded, or this computer removed in the license portal. |
| **Deactivate the current license first** | A different key is already active here. Deactivate it before you activate another. |
| **Could not reach the licensing service: check the internet connection** | Connect to the internet, and try again. |
| **Go online to deactivate, or remove this device in the license portal** | Deactivating needs internet. See [Devices](#devices). |
| **The licensing service's answer did not verify** | The answer was not signed by our licensing service, as on a network that rewrites traffic. Try another network. |
| **The licensing service refused this copy of Deformable: contact support@tangerina.io** | Write to [support@tangerina.io](mailto:support@tangerina.io). |
| **The licensing service cannot take more devices right now: contact support@tangerina.io** | Write to [support@tangerina.io](mailto:support@tangerina.io). |
| **The license state could not be written in** a folder | Your user folder is full or read-only. Free space or fix its permissions, then try again. |
| **Online access is off in this program, so the licensing service was not contacted** | The program turned online access off (in Blender, **Allow Online Access**; the Maya plugin never turns it off). Turn it on. |
| **This program uses a Developer license** | The program already activated a Developer key, so it needs no Standard key. |

### Developer messages

| Message | What to do |
|---|---|
| **This is not a license key** | Copy the whole key again from the email. A Developer key starts with `TGDF-` and has one `.` in it. |
| **This license key is not valid** | The key is cut short, changed or not signed by us. Copy the whole key again from the email. |
| **This license key needs a newer version of Deformable** | Update the SDK to the newest version. |
| **This license key is not a Deformable Developer license** | The key is for another product. Use your Deformable key. |
| **Developer licenses work in the SDKs only: the plugins need a Standard license** | A Developer key was given to the Blender or Maya plugin. Use a Standard license there. |
| **This Developer license key was revoked** | Write to [support@tangerina.io](mailto:support@tangerina.io). |
| **Developer trial ended — Contact us** | The trial key ended. Write to [support@tangerina.io](mailto:support@tangerina.io) to buy the license or to ask for a new trial key. |
| **Another Developer license key is already set in this program** | The program activated a different Developer key earlier in this run. Activate one key only, and restart the program to use another. |

## Who does what

| Step | Standard license | Developer license |
|---|---|---|
| Website and buttons | tangerina.io: **Buy license** | tangerina.io: **Contact us** and **Ask for a trial key** |
| Trial | The engine library starts it online, once per computer | We email a trial key |
| Payment | Our payment provider's payment page | An invoice from our payment provider |
| Making and emailing the key | Our licensing service | We do |
| Activation and the check | The engine library, online once and then offline between renewals, in the plugins and in every SDK | The engine library, offline, in every SDK |

The library never contacts a server of ours: the website is static, a payment provider takes the payment, a licensing
service keeps the Standard licenses, and the library checks a Developer key offline.

## The SDKs

The C, Rust and Python SDKs use the engine in your own application. Both licenses work in them: the Standard license,
for your own work on your computer, which the SDKs share with the plugins; and the Developer license, for an
application you ship to others.

The Standard trial and the Standard license belong to the computer where the engine runs. A program you build with
an SDK and run on other computers, such as your colleagues', a server or a render farm, starts a separate Standard
trial on each of them, and stops on each after 7 days unless that computer has its own seat. A container needs a
device id to start a Standard trial, and a seat activated inside a container that is thrown away stays taken until
you remove it in the license portal. To ship the engine inside an application you give to others, you need a
[Developer license](#developer-license): [contact us](mailto:support@tangerina.io).

The C SDK zip comes from the download section of [tangerina.io/deformable](https://tangerina.io/deformable#download),
the Rust crate from crates.io and the Python package from PyPI:

| SDK | How to get it |
|---|---|
| C | The zip for your platform, from the **C SDK** tab. See [C SDK](https://help.tangerina.io/deformable/v0.2.1/user-guides/c/getting-started/). |
| Rust | `cargo add deformable`. The first build downloads the engine library for your system. See [Rust SDK](https://help.tangerina.io/deformable/v0.2.1/user-guides/rust/getting-started/). |
| Python | `pip install deformable`. See [Python SDK](https://help.tangerina.io/deformable/v0.2.1/user-guides/python/getting-started/). |

Each SDK has the same license calls:

| Call | What it does |
|---|---|
| status | Reads the license state: the Developer license of this program when it activated one, otherwise the Standard state of this computer. It never goes online, so it is cheap to call often. |
| refresh | Starts the Standard trial, or renews the Standard license, when that is due. On a Standard license, call it when your program starts, so the trial starts there and not in your first tool call. A program on a Developer license never needs it: it activates its key first. |
| activate | Takes either kind of key. A Standard key is activated on this computer and needs internet. A Developer key is checked offline and holds for this run of the program. |
| deactivate | Frees this computer's Standard seat, so you can activate the key on another one. Needs internet. Under a Developer license it contacts nothing and changes nothing. |
| set online access | Keeps your program off the network when its user asked for that: nothing is sent, and the Standard trial and license work only as far as they work offline. |

With a Developer key active, status, refresh and deactivate return the Developer status and contact nothing. With a
Standard key, activate, deactivate and refresh wait for our licensing service for at most the timeout
you pass, 15 seconds by default. They are safe to call from any thread.

Activate checks the key itself first. A key in the wrong format, or a Developer key that is not valid, is refused
before anything else, with its message, such as **This is not a license key** or **This license key is not valid**:
the status `DEFORMABLE_STATUS_INVALID_ARGUMENT` in C, the kind `ErrorKind::InvalidArgument` in Rust, and in Python a
`DeformableError` with the status `INVALID_ARGUMENT` (an empty or blank key, or one that holds a NUL character,
raises `ValueError` instead). The same goes for a second, different Developer key and for a Standard key in a program
that uses a Developer license. It is not a license error, and the license state does not change.

When the license does not allow a call, the call fails with one of the license errors below, and the error's message
is the status line, such as **Standard trial ended — Buy license**. Calls that only create, read, set or free data
keep working, so your program can always clean up.

| Error | When |
|---|---|
| License required | The Standard trial ended, the computer has no Standard trial, the Standard license was removed, or the Developer trial key ended. |
| Trial limit exceeded | More than 2,500 tetrahedrons would take part in the simulation during the Standard trial; a disabled object does not count. The error's first index is that count, the second the limit. The call that adds the object (`add_object`, or `deformable_scene_add_object` in C) adds nothing, and the scene goes on with the objects it holds. |
| License needs online | The Standard trial has not started, the Standard license needs its renewal, or the clock is behind. |
| License service unavailable | Our licensing service could not be reached, or its answer did not verify. |
| License key rejected | Our licensing service refused the Standard key; or the Developer key was revoked, its trial ended, or the program is Blender or Maya, where Developer licenses do not work. |
| License storage failed | The license state could not be saved in your user folder. The message names the folder. |

### C

A Standard key, activated once on this computer:

```c
#include <stdio.h>

#include "deformable.h"

int main(void) {
    DeformableLicenseStatus status;
    if (deformable_license_activate("TGDF-XXXX-XXXX-XXXX", 15000, &status) != DEFORMABLE_STATUS_OK) {
        fprintf(stderr, "%s\n", deformable_last_error_message());
        return 1;
    }
    printf("%s\n", status.message);
    return 0;
}
```

```text
Standard license
```

A Developer key, activated at every start of your application, as its first Deformable call, before status and refresh.
Put the whole key from the email in place of `TGDF-<payload>.<signature>`:

```c
#include <stdio.h>

#include "deformable.h"

static const char DEVELOPER_LICENSE_KEY[] = "TGDF-<payload>.<signature>";

int main(void) {
    DeformableLicenseStatus status;
    if (deformable_license_activate(DEVELOPER_LICENSE_KEY, 15000, &status) != DEFORMABLE_STATUS_OK) {
        fprintf(stderr, "%s\n", deformable_last_error_message());
        return 1;
    }
    printf("%s\n", status.message);
    /* The application's engine calls come after this. */
    return 0;
}
```

```text
Developer license: Acme Inc.
```

`deformable_license_status` reads the state, `deformable_license_refresh` brings it up to date,
`deformable_license_deactivate` frees the seat, and `deformable_license_set_online_access(0)` keeps the program off
the network. The timeouts are in milliseconds. The license statuses are
`DEFORMABLE_STATUS_LICENSE_REQUIRED` (44) to `DEFORMABLE_STATUS_LICENSE_STORAGE_FAILED` (49). See
[Memory and errors](https://help.tangerina.io/deformable/v0.2.1/user-guides/c/memory-and-errors/#license-statuses).

### Rust

A Standard key, activated once on this computer:

```rust
use deformable::license;

fn main() -> Result<(), deformable::Error> {
    let status = license::activate("TGDF-XXXX-XXXX-XXXX", license::DEFAULT_TIMEOUT)?;
    println!("{}", status.message);
    Ok(())
}
```

```text
Standard license
```

A Developer key, activated at every start of your application, as its first Deformable call, before status and refresh:

```rust
use deformable::license;

const DEVELOPER_LICENSE_KEY: &str = "TGDF-<payload>.<signature>";

fn main() -> Result<(), deformable::Error> {
    let status = license::activate(DEVELOPER_LICENSE_KEY, license::DEFAULT_TIMEOUT)?;
    println!("{}", status.message);
    // The application's engine calls come after this.
    Ok(())
}
```

```text
Developer license: Acme Inc.
```

`license::status()` reads the state, `license::refresh(timeout)` brings it up to date,
`license::deactivate(timeout)` frees the seat, and `license::set_online_access(false)` keeps the program off the
network. The license errors are the `ErrorKind` variants `LicenseRequired`,
`TrialLimitExceeded`, `LicenseNeedsOnline`, `LicenseServiceUnavailable`, `LicenseKeyRejected` and
`LicenseStorageFailed`. See [Errors and threads](https://help.tangerina.io/deformable/v0.2.1/user-guides/rust/errors/#license-errors).

### Python

A Standard key, activated once on this computer:

```python
import deformable

status = deformable.license.activate("TGDF-XXXX-XXXX-XXXX")
print(status.message)
```

```text
Standard license
```

A Developer key, activated at every start of your application, as its first Deformable call, before status and refresh:

```python
import deformable

DEVELOPER_LICENSE_KEY = "TGDF-<payload>.<signature>"

status = deformable.license.activate(DEVELOPER_LICENSE_KEY)
print(status.message)
# The application's engine calls come after this.
```

```text
Developer license: Acme Inc.
```

`deformable.license.status()` reads the state, `deformable.license.refresh()` brings it up to date,
`deformable.license.deactivate()` frees the seat, and `deformable.license.set_online_access(False)` keeps the program
off the network. Activate, refresh and deactivate take a `timeout` in seconds. A refused call raises
`deformable.LicenseError`, a `DeformableError`, or one of its subclasses `LicenseRequiredError` and
`TrialLimitExceededError`. See [Types and errors](https://help.tangerina.io/deformable/v0.2.1/user-guides/python/types-and-errors/#license-errors).

## Third-party software

The [Tetrahedralize](https://help.tangerina.io/deformable/v0.2.1/user-guides/engine/preparing-meshes/#tetrahedralize) tool of the engine library,
which fills a closed triangle mesh with tetrahedrons, is based on Netgen, the mesh generator by Joachim Schöberl,
with parts by Johannes Gerstmayr. That part of the engine library is licensed under the
[GNU Lesser General Public License, version 2.1](https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html). The rest of
the engine library is proprietary.

The notice and the license text are in `THIRD_PARTY_NOTICES.txt`, which comes with the Blender plugin's `.zip` file,
the `deformable` folder of the Maya plugin, the C SDK's `.zip` file, the Rust crate and the Python package.
