Open source · Privt Voice

Open source, and how to verify it

What open source means here

One common mix-up is worth clearing up first: open source means the code is published for anyone to read, and it does not mean that the project is run in public or that anyone can slip their own code into the app you download. We build Privt Voice privately, on our own machines, and then publish the finished source so that you, or anyone you trust, can inspect it. For a privacy tool that distinction is the whole point, because the thing you actually want is the ability to check what the app does with your words, and reading the published code is what gives you that. Running the project in public or accepting code from strangers would only add risk, without adding anything you could not already confirm by reading it yourself.

The Mac app is released under the GPLv3, which lets you read it, build it, run it, and share your own modified versions, as long as those versions carry the same license forward. The parts of Privt that never reach your Mac, the sync server and this website, stay closed, and the reason is straightforward. By the time your notes arrive at our servers they are already locked with a key we have never held, so those servers have nothing to reveal about your words beyond the fact that they cannot read them. The place where your privacy is actually decided is the app on your own machine, and that is the part we open up for you to check.

What you can verify, and what you cannot

We would rather show you the exact edges of what open source gives you than let the phrase promise more than it can deliver. Here is the honest version for a signed Mac app.

That last row is the one most companies quietly skip, so here it is in plain terms. To ship a Mac app, we sign it with our developer identity and send it to Apple, which adds a signature and a notarization stamp of its own before the app is allowed to run on other people's machines. Apple builds that stamp fresh every time, and no two come out byte-for-byte identical, so nobody, ourselves included, can compile the code and produce a signed file that exactly matches the one you downloaded. That is simply how signed Mac apps work, and any project claiming a bit-for-bit reproducible notarized build is describing something Apple does not actually allow. What we can do, and do, is hand you everything you need to confirm that the file you downloaded is the one we signed and that nothing in it has changed since.

flowchart TD
  SRC["Published source
you can read every line"]
  YOUBUILD["Build it yourself
and confirm how it behaves"]
  WESIGN["We sign it with
our developer identity"]
  NOTARIZE["Apple notarizes it,
a fresh stamp every time"]
  SIGNED["The signed app
you download"]
  CHECK["Verify the signature and
our signed release manifest"]
  NOMATCH["Rebuild it to match
the bytes exactly"]
  SRC --> YOUBUILD
  SRC --> WESIGN
  WESIGN --> NOTARIZE
  NOTARIZE --> SIGNED
  SIGNED -->|what you can do| CHECK
  SIGNED -.->|what no one can do| NOMATCH
  classDef you fill:#eef4ff,stroke:#0066cc,color:#1d1d1f;
  classDef sys fill:#f0f0f2,stroke:#c9c9cf,color:#1d1d1f;
  classDef no fill:#f7f7f8,stroke:#c9c9cf,color:#86868b,stroke-dasharray:5 4;
  class SRC,YOUBUILD,CHECK you;
  class WESIGN,NOTARIZE,SIGNED sys;
  class NOMATCH no;

Build it yourself

Everything the client needs to compile is in the repository. On a Mac with the Xcode command line tools installed:

# get the source and build a release binary
git clone https://github.com/privt-labs/privt-voice-macos.git
cd privt-voice-macos
swift build -c release

What you get is the very same app we ship, produced from the same source, so this is also the best moment to watch what it does on the network. On the free tier the only thing it ever sends out is a request for the on-device speech model, once when you first launch it and occasionally afterward to repair its local copy, and you can sit and confirm that not a word of your dictation ever leaves the machine.

Verify the download

Building it yourself is one way to trust the app, and checking the copy you downloaded is the other, which your Mac already does on your behalf. The first time you open Privt Voice, macOS confirms that it carries our developer identity and has been notarized by Apple, and it will refuse to open a copy that has been tampered with since we signed it. You can run that same check by hand whenever you like:

# confirm the app is signed by us and notarized by Apple
spctl --assess --type execute -vv /Applications/Privt\ Voice.app
codesign --verify --deep --strict --verbose=2 /Applications/Privt\ Voice.app
codesign -dvv /Applications/Privt\ Voice.app 2>&1 | grep -E 'TeamIdentifier|Authority'

If those checks pass, the app genuinely came from us and has not been altered since we signed it. One habit worth keeping: rather than trusting an identifier printed here on this page, which would fall out of date the moment our signing identity changes, compare what you see against the identity listed in our signed release file, releases.json. That file is signed as well, so it stays a reliable record of who built your copy long after any number on a web page would have gone stale.

Report a vulnerability

If you have found a weakness in the app, we would rather hear it from you than read about it later, and we will work through the fix alongside you.

We ask for the recording on purpose. It clears out the automated scanner dumps and machine-written reports that now clog every security inbox, it shows that a real person has actually reproduced the problem instead of pasting a claim that merely looks right, and it puts a human on the other end of the conversation, which is the only way this kind of work has ever gone well. A report that arrives with a clear walkthrough goes to the top of the pile, and one that arrives without a recording will be asked for it before anything else can begin.

Along with the video, tell us which version you were running, the Mac and macOS version you saw it on, and the steps to reproduce it. Give us a fair window to ship a fix before you write anything up publicly, and we will keep you in the loop the whole way through. The full policy, including what falls in scope and what to leave alone, lives in SECURITY.md in the repository.

Contribute

Patches are welcome, and there is nothing unusual about the process. Before we can merge your first contribution, we ask you to sign our Contributor License Agreement, which you do by leaving a short statement on your pull request. You sign once, it covers everything you contribute afterward, and there is no bot or third-party service in the loop.

The agreement grants us a license to your contribution rather than taking ownership of it, so you keep the copyright on your own work while giving Privt Labs broad and lasting permission to use it. That one step is what lets us keep signing and shipping our own builds, and keep the freedom to license the project as the product comes to need over time, without having to hunt down every past contributor for their blessing. It is the same arrangement Signal and Threema use, for the same reason.

We open the app because a privacy promise you can check is worth far more than one you are simply asked to believe. So read it, build it, point your own network monitor at it, and hold us to what it actually does. That is the standard we want to be judged by, and the one we would like to see become ordinary.