Themis picks the cryptosystem for you, then you have to live with that choice

Four containers instead of a toolbox of primitives

Themis is a high-level cryptographic services library, not a collection of algorithm bindings. The README positions it as solving 90% of typical data protection use cases common to most apps, with the stated benefit that developers can focus on their application instead of the cryptography.

What that means concretely is four building blocks called cryptosystems, each a fixed composition of primitives.

Secure Cell is the multi-mode container for storing anything: encrypted files, database records, format-preserved strings. It is built around AES-256-GCM and AES-256-CTR, and the multi-mode part is what lets it wrap a database field rather than only a blob. Secure Message is encrypted messaging for the widest scope of applications, where you exchange keys between parties and go. It comes in two underlying pairs, ECC with ECDSA or RSA with PSS and PKCS#7.

Secure Session is the demanding one: session-oriented exchange with forward secrecy, positioned as socket encryption or a high-level messaging primitive, built on ECDH key agreement with ECC and AES encryption. Secure Comparator is a zero-knowledge proof protocol for authentication and comparing secrets without revealing them.

That composition is the design decision you are accepting. You get a coherent scheme per use case, and you give up the ability to substitute an algorithm.

The company behind it says Themis was created to build other products on top of it, naming Acra and Hermes, which is a useful sanity check on how the library is meant to be used.

One API surface across fourteen platforms, and what that costs

The repository description claims unified APIs across 14 platforms, and the language table backs it up with bindings for React Native on iOS and Android, Swift for iOS and macOS, desktop Java, C and C++, Node.js, Python, Ruby, PHP, Go, Rust and WASM. The packaging trees confirm several of those: a Swift Package.swift and themis.podspec, a Gradle setup with gradlew, a Cargo.toml workspace, a jni/ directory for Java, gothemis/ for Go, and an NSIS installer script Themis.nsi for Windows.

The value of that is real for a product with an iOS app, an Android app and an Electron backend that must agree byte for byte. The README states it provides 100% compatible API and works in the same way across all supported platforms, and that is precisely the claim a multi-platform team cannot easily reproduce with three separate crypto libraries.

The cost is a shared low point. Every platform wrapper inherits the behaviour of the C core, so a fix lands everywhere at once and a bug does too. There is no per-platform escape hatch described in the README, and the language bindings are versioned with the library rather than independently.

Coverage also has edges. The README table lists documentation and examples per language, and it is worth confirming your platform is in it before committing, because the visible portion of the table shows React Native and Swift with per-language version badges such as the react-native-themis package on npm and the themis pod on CocoaPods, and the rest of the table is truncated.

Installation is a documentation page, not a command

There is deliberately no install command in the README. The Installation section points to the installation page on the vendor documentation site for mobile, web, desktop or server-side targets, and adds one strong preference: the project highly recommends installation packages rather than building from source.

That recommendation is consistent with how the repository is laid out. Building from source means a CMakeLists.txt at the root, a configure script that the Makefile generates build/configure.mk on first run, third_party/ for bundled dependencies, tools/ for helper scripts, and clang-format plus clang-tidy wired into the build variables alongside cmake and go. It is a real build system, not a single make invocation.

Versions live in a VERSION file, and the Makefile reads it with a fallback: the VERSION variable is derived from git describe --tags when a .git directory exists, otherwise from cat VERSION. A separate VERSION_SHORT holds the plain X.Y.Z number without build number or commit hash, and LIBRARY_SO_VERSION is the field the comments tell you to bump when you make backwards-incompatible API or ABI changes.

For package-based installs, the visible documentation trail points at CocoaPods with a pod named themis for Swift, and npm with react-native-themis for React Native. The README does not give versions or registry commands for the other twelve platforms.

The CHANGELOG.md at the repository root is where release notes live, and the vendor documentation site is the installation reference, not the repository.

Secure Session buys forward secrecy and charges for the infrastructure

Of the four, Secure Session is the one with an infrastructure bill attached, and the README is direct about why: forward secrecy gives better security guarantees and demands more demanding infrastructure. It can work as socket encryption or session security, or as a high-level messaging primitive, but the parenthesis matters, because the latter path needs additional infrastructure such as PKI.

That is a deployment fact, not a library fact. Secure Session uses ECDH key agreement with ECC and AES encryption.

Secure Message is the opposite trade. It is described as the simplest encrypted messaging solution for the widest scope of applications, where exchanging keys between the parties is the whole setup. Its underlying cryptosystems are ECC with ECDSA or RSA with PSS and PKCS#7.

Choosing between them is a question about your threat model and your infrastructure budget, and Themis does not make that choice for you. It makes the primitive selection inside each one.

Use cases that reach past the crypto

Some of the README's use cases are not cryptography in the narrow sense, and that is where the library's scope becomes visible. Encrypting stored secrets covers API keys, session tokens and files. Encrypting sensitive database fields before storing is described as application-side field-level encryption, which changes your schema work because the value in the column is no longer the value in the application.

Searchable encryption, data tokenisation and data masking are listed, but the README attributes them to Themis used together with Acra, which is a separate product rather than something Themis does alone. Read that line as a dependency, not a feature claim.

Secure Comparator carries its own application: comparing secrets between parties without revealing them, framed as zero-knowledge proof based authentication. In practice that means a password or a value can be checked against a server-held proof without the server learning it, which is the difference between a stolen-database incident and a non-event for that field.

The end-to-end encryption case is described with a specific shape: encrypt data locally on one app, use it encrypted everywhere, decrypt only for an authenticated user, with either centralised or decentralised architecture. That sentence encodes the hard part of any such system, which is not the encryption but the key distribution around it.

Maintenance, packaging spread, and the honest limits

The release cadence is regular and recent. Version 0.15.7 shipped on 2026-04-24 with iOS tooling updates and iOS Privacy Manifest support, 0.15.6 on 2026-01-09 added experimental React Native support for 16 KB page size on Android 15 and later, and 0.15.5 added the same page size support on 2024-08-21. The last push was on 2026-04-24 and the repository is not archived. The 16 KB page size work is the tell that platform requirements are being tracked against new Android releases rather than left to downstream integrators.

The zero-major version is the thing to weigh. A library at 0.15.x communicates that the API may still move, and the Makefile comments about incrementing LIBRARY_SO_VERSION on breaking API or ABI changes show the project manages that boundary consciously, but it does mean you should read the CHANGELOG.md between upgrades rather than bumping a constraint.

The build system is wide. CMakeLists.txt, configure, Makefile, Package.swift, themis.podspec, Cartfile and Cartfile.resolved for CocoaPods Carthage, build.gradle with gradle.properties and settings.gradle, Cargo.toml, PKGBUILD.MSYS2 for MSYS2, Themis.nsi for Windows, plus .clang-format, .clang-tidy and a Doxyfile. That much build metadata across that many package managers is the cost of the unified API, and every one of them is a place a dependency update can go wrong.

Licensing is Apache-2.0, so embedding Themis in a proprietary product carries no copyleft obligation. What the Apache-2.0 terms do not do is choose an algorithm for your data or verify your key handling, and no library API can do either.

Editorial conclusion

Themis suits a team shipping one product across several platforms that wants identical APIs rather than three separate crypto stacks, and the README's claim of a 100% compatible API across platforms is exactly the property such a product needs. It is the wrong choice if you want to choose primitives yourself, since Secure Cell is fixed to AES-256-GCM and AES-256-CTR and Secure Session to ECDH with ECC and AES. Verify first which container your use case actually needs, since its high-level messaging use can require additional infrastructure such as PKI, and check the release state: 0.15.7 shipped on 2026-04-24 with the last push on the same date.

Frequently asked questions

Official sources

1. cossacklabs/themis on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases