libtacky

An XMPP client library in Tcl 9, Rust and C. It holds the protocol, the local store, end-to-end encryption, calls and file transfer. Apps talk to it through one JSON API. Tcl programs and gateways load its packages directly.

Version 1.2.7. Licence GPL-3.0.

What you get

• dist/libtacky.a: the whole library, Tcl included, behind embed/tacky.h.
• dist/tackyd-json: the same library over stdin and stdout.
• A wasm build for a browser worker (make wasm).
• Builds for Linux, Windows, Android and iOS (platforms/).
• Tcl packages under tacky::*: session, client, component, HTTP, and the OTR, MTProto and Matrix protocol layers.
• dist/tackyd: runs a Tcl program with no Tcl installed.
• Native crates with C ABIs: tacky-core, tacky-crypto, tacky-keyring, tacky-omemo, tacky-olm, tacky-media.

The API is described once, in schema/tacky.schema.json: 72 modules, 638 methods, 204 events, 198 types. HANDBOOK.md documents all of it, with the Tcl reference and the guides under docs/. The handbook (make handbook) and the host bindings are generated from the schema.

Features

• One SQLCipher store per account, keys in a sealed keyring
• A message is acknowledged only after it is stored
• SASL2, Bind 2, FAST, SCRAM with channel binding
• Stream management with resume, CSI, reconnects
• Entity Capabilities 2.0, Happy Eyeballs, authentication pipelining
• TLS through rustls, certificate pins, no plaintext fallback
• STARTTLS, direct TLS and WebSocket
• SOCKS5 proxy, Tor and I2P per account
• OMEMO 0.3 and OMEMO 2 under one identity
• OMEMO automatic trust management (XEP-0450)
• OTR v3 secret chats with SMP, announced to the contact's devices
• Telegram secret chats through a gateway, and MTProto secret chats directly between two XMPP devices (experimental)
• Matrix end-to-end encryption (Olm, Megolm, SAS verification) through a gateway
• Group chats (MUC), bookmarks, archive (MAM) with catch-up
• Room hats, mention notifications, invitation links, spaces
• Replies, reactions, corrections, retractions, mentions
• Polls (Fluux's urn:fluux:poll:0), stickers, silent and scheduled messages
• Publish-subscribe on any service, microblogging, stories
• WebXDC apps, online meetings, payment requests (work in progress)
• HTTP upload and Jingle file transfer, encrypted
• Audio and video calls, group calls (Muji)
• XEP-0114 components for gateways and bots

docs/features.md has one row per specification with its status. Our own extensions (urn:tacky:*) are specified under docs/protocol/.

status	meaning	specifications
🔵 MOSTLY	implemented and tested, not checked by hand against other software	171
🟡 WIP	partly implemented or partly tested	27
🔴 TODO	not implemented, at most reserved in the API	9
🟢 DONE	checked by hand; set by a maintainer	0
⛔ NOT SUPPORTED	deliberately not implemented	1

How it fits together

 app (libtacky.a), tackyd-json, or a browser worker (wasm)
   │  JSON  ["module","method",{args},token] →   ["result"|"error",token,…] ←
   ▼
 embed/tacky.c      one backend thread, one Tcl interpreter
   ▼
 tacky/core/wire    dispatch through the schema's allow-list
   ▼
 tacky/xmpp/client  one module per area (account, roster, message, muc, …)
   ├── tacky/xmpp/session   the XMPP session, in Tcl
   │     └── tacky::core    tacky-core (Rust): DNS, connect, TLS, XML
   ├── tacky/core/storage   SQLCipher store per account
   ├── tacky::core::keyring tacky-keyring (Rust): the key vault
   ├── tacky::omemo         tacky-omemo (Rust): the OMEMO ratchet
   ├── tacky::olm           tacky-olm (Rust, vodozemac): Olm and Megolm
   ├── tacky/http           HTTP/1.1 in Tcl
   └── tacky::media         calls: webrtc | datachannel | host | remote

 tacky/xmpp/component      an XEP-0114 component, no client loaded

• Rust reads untrusted bytes and holds keys: the stream, TLS, parsers, crypto, OMEMO.
• C binds each crate to Tcl, and runs media (libwebrtc or libdatachannel).
• Tcl is everything that means something: the session, the client, the store, HTTP.

Calls use one native media backend per build, chosen by MEDIA_BACKEND. ROBOTS.md has the full layout and the reasons behind it.

component	language	what it is	code	tests	coverage
core	Tcl	tacky/core: the wire API dispatch, the per-account store, the keyring layer	2,906	1,814	99.1 % procs
	C	ext/core: the Tcl binding of tacky-core and the keyring; the SQLCipher crypto provider	4,031	3,552	98.8 % lines
	Rust	tacky-core: DNS, TCP, TLS (rustls), WebSocket, the XML stream, the C ABI; tacky-keyring: the key vault	13,182	8,159	98.8 % lines
crypto	C	ext/crypto: the tacky::crypto binding	1,444	790	99.4 % lines
	Rust	tacky-crypto: hashes, HMAC, HKDF, PBKDF2, AES, X25519 with a C ABI	2,543	2,933	99.9 % lines
http	Tcl	tacky/http: HTTP/1.1 client for uploads and downloads	1,068	2,199	100.0 % procs
media	Tcl	tacky/media: the call media contract and its backends	1,009	1,906	97.8 % procs
	C	ext/media: the binding; tacky-media: the media C API over libdatachannel, with audio (Opus) and video (VP8) engines	9,949	10,651	--
	C++	tacky-media/webrtc: the same C API over libwebrtc	4,979	342	--
olm	C	ext/olm: the tacky::olm binding of Olm and Megolm; Matrix above it is the client's	1,042	375	99.8 % lines
	Rust	tacky-olm: Olm, Megolm, the SAS and Ed25519 keypairs for Matrix's end-to-end encryption over vodozemac, with a C ABI	827	1,022	100.0 % lines
omemo	C	ext/omemo: the tacky::omemo binding	979	398	98.6 % lines
	Rust	tacky-omemo: X3DH, Double Ratchet, XEdDSA; OMEMO 0.3 and OMEMO 2	2,080	4,045	99.8 % lines
xmpp	Tcl	tacky/xmpp: the session, the client modules, the XEP-0114 component, the in-process test driver	90,086	159,733	99.0 % procs
everything else	C, Tcl, Python, sh, make, CMake	embed/, examples/, tools/, test runner, build files; not in the total	11,204	5,917	--
total (without everything else)	Tcl 95,069 · C/C++ 22,424 · Rust 18,632		136,125	197,919	Tcl 99.0 % procs · Rust 99.2 % lines · C 98.8 % lines

code: lines of code, no blanks, comments or generated files. tests: lines of test code for that part. The total leaves out everything else. coverage: Tcl counts procedures called, Rust and C count lines run, from the make coverage-all run on 2026-11-07 at commit f5483b52.

The media C and C++ have no coverage figure: the coverage run uses the default webrtc build, and libwebrtc is not measured.

Status and tests

The API is stable. A change that breaks a host comes with a new major version.

Unit suites run against in-process peers: a fake server with real SCRAM, TLS and WebSocket, a stream relay, fault shims for the C bindings, and reference vectors for the ratchet. Integration suites (tests/integration) run against a real server in a container, with OMEMO echo bots beside it.

Integration results, measured on 1.2.7 (2026-11-10, Prosody and ejabberd three rigs each, MongooseIM and Openfire two rigs each, at commit c9421614, 1.2.6 with the destroyed room's first fix; then the bookmarks and MUC suites on Prosody and ejabberd at ce29cfc7, and test_calls and test_groupcall on every server at 7c5c13ec), the rigs' media library present:

server	passed	failed	skipped
Prosody 13	449	0	37
ejabberd 26.09	470	0	16
MongooseIM 6.10.0	395	0	91
Openfire 5.1.2	390	0	96

Four cases failed in the full run and are counted from runs alone: Prosody's test_catchup_history (19 of 19 alone) and test_stickers (3 of 3), ejabberd's test_retraction (8 of 8; its OMEMO 2 retraction case is an ejabberd flake older than 1.2.6, about one run of four alone), and MongooseIM's test_catchup_history (19 of 19). test_calls' five new cases pass on all four servers (9 of 9 each). Openfire is built from the release tarball with the OF-3416 backport. What MongooseIM and Openfire lack is marked off them by name in the suites and said in their launchers' headers. Skips are features a server or its rig lacks.

docs/rigs.md has the matrix behind this table: per suite and server, the cases that run and those skipped, with the reason, and the cases no server runs. make stats regenerates it, from a tests/servers/sharded.sh all run with RIG_LOGS=_build/shards.

Nothing has been checked by hand against public servers or other clients yet. That is why no feature is DONE.

136,125 lines of code, 197,919 lines of tests (22,871 of them integration suites), 11,012 test cases. Coverage: Tcl 99.0 % procs · Rust 99.2 % lines · C 98.8 % lines (make coverage-all on 2026-11-07 at commit f5483b52).

suite family	files	cases
Tacky unit suites (tests/client, tests/http, tests/tcl)	266	8291
Tacky integration suites (tests/integration, need a server)	85	476
Rust: tacky-core	53	462
Rust: tacky-keyring	6	54
Rust: tacky-crypto	21	134
Rust: tacky-omemo	15	181
Rust: tacky-olm	5	24
Tcl extensions (ext/*)	21	1344
C: tacky-media: libtackymedia, rtc-ma, rtc-mv (ctest programs)	42	42
C++: tacky-media: webrtc (ctest programs)	4	4
total	518	11012

make docs regenerates these numbers. Coverage comes from the last make coverage-all; its full report is _build/cov/REPORT.md.

Building

Everything builds in libtacky's container image. The machine needs git and docker or podman.

git clone --recurse-submodules ssh://git@dev.another.im:3022/another-im/libtacky.git
cd libtacky
make all test               # build, run every suite that needs no server
make all test REQUIRE=1     # the gate: a missing prerequisite fails

MEDIA_BACKEND is webrtc (default), datachannel or none.

target	what it does
make, make dist	build everything; dist/libtacky.a
make tackyd-json, make tackyd	the two executables
make test	every suite that needs no server
make test-tacky-prosody, -ejabberd, -mongooseim, -openfire	integration suites against a server in a container
make coverage-all	the coverage run behind the table above
make audit	every Cargo.lock against the RustSec advisory database (audit.toml is the allow-list); in make gate
make docs	handbook, README numbers, DOAP file, Rust API docs
make handbook	HANDBOOK.md, from the schema and docs/
make help	every target

More in docs/building.md.

Using it

An app links embed/tacky.h and speaks JSON:

tacky *tacky_create(const char *const *backend_args, tacky_emit_fn emit, void *ud);
void   tacky_send(tacky *t, const char *json, size_t len);   /* ["module","method",{args},token] */
void   tacky_destroy(tacky *t);                              /* replies and events arrive at emit */
void   tacky_destroy_wait(tacky *t, unsigned int max_ms);

A Tcl program loads the packages, from a built checkout or through dist/tackyd:

package require tacky::xmpp::component
set h [tacky::xmpp::component new -domain gateway.example.org -secret $secret \
           -host 127.0.0.1 -port 5347 -command onEvent]
tacky::xmpp::component connect $h

examples/component/echo.tcl is a complete component. The handbook, HANDBOOK.md, documents every method, event and Tcl command.