Documentation

Install#

Windows 10 build 1809 or later, 64-bit. The WebView2 runtime is required; it is already present on current Windows 11, and the installer fetches it if it is missing.

Two files are published with each release. Take the -setup.exe unless you have a reason not to: it is smaller and it installs for you alone, with no administrator prompt. The .msi is the standard Windows installer package, for deploying Trynta across machines.

Download .exe  .msi for deployment

All releases — older versions, the full notes, and source archives.

Get-FileHash .\Trynta_0.1.0_x64-setup.exe -Algorithm SHA256

Compare the result with the hash in the release notes. If they differ, delete the file and do not run it.

Uninstalling

Uninstall from Settings → Apps like any other program. That removes the application. It does not remove your vault — see Files on disk for where it lives and how to delete it deliberately.

Create your vault#

On first launch Trynta asks for one thing: a master password. There is no email, no account and nothing to confirm.

Choosing one

Length beats complexity. Four or five unrelated words are stronger than a short string with punctuation in it, and far easier to type correctly every day. If you want Trynta to pick for you, the passphrase mode of the generator does exactly this — though you will have to create the vault before you can reach it, so generate it, then change the master password in Settings.

What happens when you press the button

Your password goes through Argon2id, a key derivation function designed to be slow and to need a lot of memory, so that guessing at it in bulk is expensive rather than free.

Trynta calibrates the cost to your machine: it measures a derivation and picks parameters that land near 700 ms on your hardware, so a faster computer automatically gets a harder setting. There is a hard floor it will never go below, so a slow machine cannot calibrate its way down to something weak. The chosen cost is written into the vault header, which is what lets the same file open correctly on a different computer.

The five-minute tour#

The first time you unlock, Trynta walks you through four cards — the item list, the generator, the security report and backup. Nothing is blocked while it is open; you can use the app underneath it, and Esc ends it.

It runs once. Settings → Help → Guided tour plays it again whenever you want it.

The window itself is three columns, and it stays that way everywhere:

• Left — your vaults, then the whole library by type, then the tools.
• Middle — the list of whatever you selected on the left.
• Right — the item you selected in the middle.

Items and vaults#

Trynta stores four kinds of thing, and they are genuinely different types rather than one generic entry with optional fields:

• Logins — username, password, website, one-time code, notes.
• Secure notes — free text, encrypted like everything else.
• Cards — number, expiry, security code, cardholder.
• Identities — the personal details forms keep asking for.

New item is the button at the top of the middle column. Pick the kind and the vault it belongs to, fill in what you have, save.

Vaults

A vault is a group — Personal, Work, Family, whatever suits. There is no limit, each one can be renamed and given its own colour, and every item lives in exactly one of them. Manage them from Settings → Vaults.

They are an organisational boundary, not a security one: everything is unlocked by the same master password at the same time.

Finding things

The list has quick filters across the top — All, Weak and Has 2FA — which combine rather than replace one another. The sort control cycles through Recent, A–Z, Updated and Created. Favourites in the sidebar collects anything you have starred.

For anything faster than that, press Ctrl K. That is a fuzzy search across your whole vault and the app's actions at once. The index is built in memory when you unlock and thrown away when you lock — it is never written to disk.

Deleting

Deleting an item asks for two things: your master password, and the item's name typed out. Both are checked in Rust, not in the interface.

The threat this is built for is an unlocked vault on an unattended desk. A password alone is muscle memory; a password plus a name you have to read off the screen is not something done by accident.

Copying and revealing#

These are two different operations with two different security stories, and the difference is worth understanding.

Copy

The password is decrypted in Rust and written straight to the Windows clipboard. It never enters the webview — the part of the application that draws the interface never receives the value at all. Ctrl C copies the password of whatever row is highlighted in the list, without opening it.

The clipboard clears itself after 30 seconds by default. It only clears if the clipboard still holds what Trynta put there, so copying something else in the meantime leaves your clipboard alone.

Reveal

Revealing is the one sanctioned path a plaintext takes to the screen: one field, one item, on an explicit click. It is rate-limited to twenty reveals per rolling minute, and it clears on blur, on navigation and on lock. The interface never stores it, caches it or logs it.

Settings → Security can require your master password for every reveal. It is off by default: the rate limit already forces re-authentication, and typing a master password dozens of times a day is its own risk.

The generator#

Two modes, both drawing from the operating system's cryptographic random source.

Passwords

Set the length and choose which character classes to include — uppercase, digits, symbols — and optionally exclude the characters that look like each other (l, 1, I, 0, O), which matters when a password has to be read aloud or copied by hand.

Selection uses rejection sampling. That is the unglamorous detail that keeps every character equally likely instead of quietly favouring the start of the alphabet, which is what a naive modulo does.

Passphrases

Words come from the EFF long word list — 7,776 words, chosen so that each one contributes exactly 12.9 bits. The list ships inside the application and is verified against its published hash at build time, so it cannot be swapped for a shorter one.

Words are separated by spaces. A hyphen makes the boundaries ambiguous when a phrase is read out or retyped, and the separator adds no strength either way.

The number underneath

That figure is entropy in bits: the real measure of how many guesses an attacker would need, computed from the settings that produced this password rather than from inspecting the result. It is not a bar that turns green when you add a symbol.

History

The panel below keeps what you generated — but only the kind, the entropy and the timestamp. Never the value. A list of your recent passwords sitting in a side panel would be a strange thing for a password manager to keep.

One-time codes#

Trynta generates two-factor codes locally, to RFC 6238 — the same standard every authenticator app implements.

On a login, paste either the otpauth:// link behind the QR code or the bare setup key. Trynta works out the algorithm, digit count and period from the link; a bare key uses the usual defaults.

It handles SHA-1, SHA-256 and SHA-512, and both six and eight digit codes. Plenty of services use something other than the default and most tools quietly assume nobody does.

The ring around the code is the countdown to the next one. Click the code to copy.

The security report#

A score for the whole vault, with the arithmetic that produced it printed underneath — you can see exactly why it says what it says. A vault with too little in it to score shows — rather than a zero that reads as catastrophic.

Five figures, and each one is a list you can click into:

The breach check

Off by default. Turn it on with Settings → Security → Watch for breaches.

Here is exactly what happens when it runs:

1. Trynta computes the SHA-1 hash of a password, on your machine.
2. It sends the first five hexadecimal characters of that hash — and nothing else — to the Have I Been Pwned range API, with Add-Padding: true so the response size reveals nothing either.
3. The service returns every hash suffix sharing that prefix, typically several hundred.
4. The comparison happens locally. The full hash never leaves the machine.

No password, no username, no site name and no identifier for you is transmitted. The request carries no cookie and nothing that names the user. It runs at most once every 24 hours.

Opening the report sends nothing at all. The report reads a local cache; refreshing that cache is a separate action you press deliberately.

Windows Hello#

Optional, off by default, and available only if your device has Hello set up. Settings → Security → Unlock with biometrics.

Enabling it asks for your master password once, right there. There is no moment when the running app is holding your password and could enrol silently — it is used once at unlock and dropped — so enrolment has to ask, and it verifies the password before storing anything.

How it works

Windows Hello creates an asymmetric key pair that the operating system gates behind your face, fingerprint or PIN, and stores it in the TPM on machines that have one. Trynta never sees the private key.

It asks the OS to sign a fixed challenge — that is what makes the Hello prompt appear — and derives a wrapping key from the signature that comes back. Two properties make this sound: the signature is deterministic, so the same challenge always yields the same bytes; and Windows destroys the credential if your Hello enrolment changes, at which point Trynta falls back to the master password rather than trying to track enrolment itself.

The wrapping key protects your master password, which is handed to Windows' own secure storage (DPAPI plus Credential Manager) and released only after Hello signs.

Why it stores the password, not a key

Storing a derived key instead would skip the Argon2id derivation, and that derivation is the thing that makes a stolen vault expensive. Somebody who compromised the secure store would then hold something strictly more useful than your password. Storing the password means an attacker who defeats Hello gets exactly what you have and no more, and every check on the ordinary unlock path still runs.

Backup and restore#

Settings → Backup and restore. Export writes one encrypted file wherever you choose. Nothing is uploaded.

The archive has its own passphrase, chosen for the file and independent of your master password. So you can put a backup somewhere you would not put your master password, and you can change your master password without invalidating archives you already made.

The file carries its own Argon2id salt and cost, so it stays expensive to attack on its own terms, and it is signed — a restore refuses an archive that has been altered.

Restoring replaces the current vault with the archive's contents. Take a fresh export before you restore an old one if there is anything in the current vault you want to keep.

Themes#

Settings → Appearance. Light, dark, or follow the system. A new install starts on light. Switching is instant — no reload, no flash — because every colour in the application resolves through a token layer, so changing theme is a change of data rather than a change of stylesheet.

Writing your own

A theme is a JSON file: an id, a name, which built-in mode it replaces, and a map of CSS custom properties to values.

{
  "id": "midnight",
  "name": "Midnight",
  "mode": "dark",
  "tokens": {
    "--surface-app": "#0b0d12",
    "--surface-panel": "#12151c",
    "--text-primary": "#e8eaf0",
    "--accent": "#7c86ff"
  }
}

Import it from Settings. Anything you do not set keeps the built-in value, so a handful of tokens is a perfectly good theme.

Every setting#

The complete list, with defaults. Where a default looks surprising, the reason is in the last column.

Keyboard#

Files on disk#

Everything Trynta stores lives in one directory:

%APPDATA%\Trynta\vault.db

That is normally C:\Users\<you>\AppData\Roaming\Trynta. One SQLite file, with the secret fields encrypted individually inside it.

Moving to another machine: copy that file to the same path on the new machine and unlock with the same master password. The derivation cost travels in the file's header, so it opens correctly even on hardware that would have calibrated differently. A backup archive is the tidier route and the one to prefer.

Deleting everything: uninstall, then delete that folder. Nothing is left anywhere else — except the Hello credential if you enrolled one, which is removed by turning biometric unlock off before you uninstall.

Architecture#

The shell is Tauri v2 — which matters mostly for what it is not. There is no bundled browser engine and no Node runtime sitting next to your secrets; the interface renders in the WebView2 already on the system.

Everything that touches a secret is Rust. All key derivation, all encryption and decryption, all storage, all clipboard writes. The interface is React and TypeScript, and it never holds a key — not a master key, not a vault key, not an item key. No key material crosses the IPC boundary in either direction.

crates/
  keyring-crypto/    KDF, AEAD, envelopes, key hierarchy, manifest, backup format
                     — depends on nothing else in the workspace
  keyring-store/     SQLite schema, migrations, header, item repository
                     — depends only on keyring-crypto
src-tauri/
  commands/          the IPC surface; orchestration only, no logic
  platform/          windows/ and macos/ behind traits; the only place `unsafe` is allowed
  services/          generator, strength, TOTP, breach, icons, report, theme
src/
  features/          the interface, in vertical slices
  ipc/               the only place in the frontend that can call the backend
  theme/             the token layer and runtime theme loading

Item lists carry decrypted metadata only — title, subtitle, icon, badges. Secret fields are fetched one at a time, on demand, by an explicit command. The layering is enforced by build checks rather than by convention, and the crate names are historical: the project was called Keyring before it was called Trynta.

Cryptography#

Standard primitives, used the documented way. Nothing here is novel.

The key hierarchy

Each item is encrypted under its own key. Item keys are wrapped by a per-vault key, and vault keys are wrapped by keys derived from your master password. Decrypting one item unwraps one item key; it does not hand over the vault.

Length hiding

Plaintexts are padded to a 256-byte boundary (ISO/IEC 7816-4) before encryption, so a ciphertext's length cannot distinguish a four-digit PIN from a long note. Padding is always at least one byte, because an exact multiple would otherwise be ambiguous.

Memory

Every key and plaintext buffer is zeroized when it drops, and buffers are pre-sized so that growth cannot leave an orphaned copy behind. The three 32-byte keys a live session holds are pinned into RAM with VirtualLock, keeping them out of the page file.

The Argon2 derivation buffer is a documented exception — it is far larger than the lockable working set and may be paged. Locking pins an address rather than a value, and a hibernation image is a full memory dump whatever is locked. Zeroization is best-effort by nature and the project does not claim otherwise.

Dependencies

The crypto crates are pinned to a single RustCrypto generation, and the build fails if a second copy of digest, sha2, rand_core, aead or curve25519-dalek appears in the tree. No release candidates are permitted anywhere in the crypto path.

What leaves your machine#

Two requests exist in the entire application. Both are optional.

No sign-up, no sync, no telemetry, no analytics, no crash reporter. Trynta never probes the sites you keep accounts with — not for icons, not for password-change endpoints, not for anything.

The 3,772 brand marks in the interface are compiled into the binary. They are never fetched, and that is the point: a favicon request per entry would announce, in the clear, a list of every service you hold an account with.

A build check counts the outbound call sites and fails the build if a third one ever appears. This is enforced, not promised.

Update downloads are verified by Tauri's updater against a public key compiled into the binary. There is no code path that can skip that check.

What this protects against#

It is designed to survive:

• Someone who copies your vault file — a stolen laptop, a backup drive, a disk image.
• Someone who reads the database directly. The file is not the boundary; the ciphertext is.
• Someone watching the network. Two requests exist and neither carries a secret or an identifier.
• A tampered backup or update. Both are signature-checked and both fail closed.
• A hostile theme file. Validated in Rust before anything is applied, and it cannot reach the network.

It does not protect against:

• Malware running as you, while the vault is unlocked. At that point the attacker has the same access you do. No password manager solves this.
• A keylogger capturing your master password as you type it.
• A forgotten master password. There is no recovery, by design.
• Someone at your unlocked machine, beyond the confirmations on destructive actions.
• A hibernation image or crash dump, which captures memory whatever is locked in it.
• Phishing. There is no autofill yet, so nothing checks the domain for you — you do.

The repository's SECURITY.md sets this out in full, including an explicit list of what has not been verified.

What is not built#

• Sharing. Multi-owner credentials — two people genuinely co-owning one login — are the reason the project exists and they do not exist yet. The key material is generated and reserved; nothing uses it.
• Sync. Nothing is synchronised between devices.
• Autofill and browser extensions. When they arrive, matching will be on the registrable domain through the Public Suffix List, never a substring — that difference is what separates a password manager from a phishing accessory.
• Import from another password manager.
• Linux. Not started. The per-platform pieces — secret storage, biometric unlock, the clipboard — would all need writing, and we would rather say so than list it as coming.
• macOS — next up. The macOS code is written and it built and passed the full gate once, on 17 August 2026. Verifying it needs a Mac to run it on, so there is no build to download yet. It is the next platform.
• Accounts, subscriptions, payment or licence gating. None of it is in the repository and none of it is stubbed for later.

Troubleshooting#

I forgot my master password

The vault cannot be opened. There is no recovery mechanism, no backdoor and no support route that changes this — the password is not stored anywhere to be recovered from. If you have a backup archive with a passphrase you do remember, restore that.

Unlocking is refusing my password after several attempts

That is the backoff. It grows with each failed attempt and it survives restarting the app, so closing the window does not reset it. Wait it out.

There is deliberately no wipe-after-N-failures: anyone holding your file could trigger it, which turns a safety feature into a way to destroy your data.

Windows Hello stopped offering to unlock

Windows destroys the stored credential whenever Hello enrolment changes — a new fingerprint, a reset PIN, a rebuilt profile. Trynta falls back to the master password. Unlock with it, then turn biometric unlock off and on again to re-enrol.

It will also ask for the master password regardless once 14 days have passed since the last password unlock.

Windows says the installer is from an unknown publisher

Expected — the artefacts are unsigned. See Install, and check the SHA-256 before running it.

The window is blank, or will not start

Almost always a missing or broken WebView2 runtime. Install the Evergreen Runtime from Microsoft and start Trynta again. Your vault is untouched by this; it is a separate file.

Something I copied is still on the clipboard

Trynta only clears the clipboard if the contents are still what it put there. If you copied anything else in between, it deliberately leaves your clipboard alone rather than wiping something of yours.

Getting help#

Found a security issue? Please report it privately through GitHub's advisory form rather than opening a public issue.

Anything else — a bug, a question, an idea — is welcome as an issue.

The changelog records every release and what changed in it. The source is the whole product: there is no closed component, licensed under AGPL-3.0-or-later.

Download Trynta