# pktito: the documentation, whole # pktito-cli Source: https://pktito.net/developers/cli Reference for pktito-cli, the app's transcription from a terminal, with its options, JSON output and exit codes. `pktito-cli` is the app's transcription from a terminal: the same files in, the same model, and the same files out. ## Getting it on the PATH It comes with the app. - **Windows**: the installer adds it to the PATH; open a new terminal after installing. - **Linux**: the .deb installs it in `/usr/bin`. - **macOS**: choose **Install Command Line Tool…** from the pktito menu, which links it into `/usr/local/bin`. Until then it is at `/Applications/pktito.app/Contents/MacOS/pktito-cli`. ## Usage ```sh pktito-cli talk.mp4 # the transcript, on the terminal pktito-cli --srt *.mp4 # subtitles beside each file pktito-cli -m multilingual -f json -o out interview.m4a pktito-cli models # which are here, which is in use pktito-cli download parakeet-tdt-0.6b-v3 ``` ## Options | Option | Effect | | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `-m`, `--model MODEL` | A model's name (`parakeet-tdt-0.6b-v2`), its label (`english`, `multilingual`), the last part of its name (`v2`, `v3`), or the path to a `.pkf`. A named model must be downloaded first. | | `-f`, `--format F` | `txt`, `md`, `srt`, `vtt` or `json`. `--txt`, `--md`, `--srt`, `--vtt` and `--json` are the same. | | `--times` | Each sentence's start time before it, in `txt` and `md`. | | `-o`, `--output PATH` | For one file, the file to write. For several, or a PATH that is a folder or ends in `/`, the folder to write into, made if it isn't there. | | `-t`, `--threads N` | Threads to use. The default is one a core, or `PKTITO_THREADS` when it is set. | | `-q`, `--quiet` | No progress, and no line naming each file written. Progress only shows on a terminal anyway. | | `-h`, `--help` | The usage text. | | `--version` | `pktito-cli` and its version. | [Saving](/docs/saving) says what each format holds. ## Where transcripts go - **One file, no `-o`**: the transcript goes to standard output. - **Several files, no `-o`**: each transcript is written beside its file, as `talk.txt` for `talk.mp4`. - **With `-o`**: to that file, or into that folder. Nothing is written over: a second `talk.txt` becomes `talk 2.txt`. Errors go to standard error. `pktito-cli` reads files, not standard input. ## models ```sh pktito-cli models ``` Lists each model, its size, and whether it is downloaded or in use. ## download ```sh pktito-cli download parakeet-tdt-0.6b-v2 ``` Downloads a model for the app and `pktito-cli` both, taking the same names as `-m`. It asks nothing, resumes, retries while the network is away, and prints the model file's path when done. The models folder is `models` in the app's data folder: | System | Folder | | ------- | ---------------------------------------------- | | macOS | `~/Library/Application Support/net.pktito.app` | | Windows | `%APPDATA%\net.pktito.app` | | Linux | `~/.local/share/net.pktito.app` | ## JSON output `-f json` writes one object: ```json { "file": "talk.mp4", "duration": 63, "model": "parakeet-tdt-0.6b-v2", "segments": [ { "start": 0, "end": 0.9, "text": "Hello there.", "words": [ { "start": 0, "end": 0.4, "text": "Hello" }, { "start": 0.4, "end": 0.9, "text": "there." } ] } ], "captions": [{ "start": 0, "end": 1.5, "lines": ["Hello there."] }] } ``` | Field | Meaning | | -------------------------- | ---------------------------------------------------------------------------------------- | | `file` | The transcribed file's name, without its folder. | | `duration` | The recording's length, in seconds. | | `model` | The name of the model that made the transcript. | | `segments` | The sentences, in order. | | `segments[].start`, `.end` | When the sentence starts and ends, in seconds. | | `segments[].text` | The sentence, punctuated and cased. | | `segments[].words` | Its words, each with `start`, `end` (seconds) and `text`, the word with its punctuation. | | `captions` | The subtitle track's cues, the ones `srt` and `vtt` write. | | `captions[].start`, `.end` | When the cue is shown and hidden, in seconds. | | `captions[].lines` | The cue's text, as its one or two lines. | Times are in seconds, to the millisecond. ## bench ```sh pktito-cli bench recordings/ ``` Times the transcription of each file, or of a folder's audio and video, and gives the total as times real time. Decoding the file isn't counted. It takes `-m`, `-t`, `-q` and `--json`. `--json` gives `pktito_cli`, `model`, `backend`, `threads`, `audio_s`, `seconds` and `x_real_time` for the whole, and `files`, each with `file`, `audio_s`, `seconds`, `x_real_time` and `transcript_sha256`. [AliceBench](/developers/benchmarks) is built on it. ### Finding the fastest thread count By default pktito uses a thread for each core. On a chip with two kinds of core, such as Intel's performance and efficiency cores or an Arm chip's big and little ones, it also times the fast cores alone against all of them early in the first long recording, and keeps whichever was quicker. That choice is a quick guess. Hyperthreading, other work on the machine, or a close race can make it pick the slower one. If you will transcribe a lot on one machine, bench a few of your own files at the default, then at a few fixed thread counts, and keep the fastest: ```sh pktito-cli bench recordings/ # the default pktito-cli bench -t 8 recordings/ # e.g. the number of performance cores pktito-cli bench -t 12 recordings/ ``` Then pass `-t` when you transcribe, or set `PKTITO_THREADS`, which `pktito-cli` and the app both read. The transcript is the same at any thread count; only the speed changes. ## Exit codes | Code | When | | ---- | ------------------------------------------- | | 0 | Success. | | 1 | Something failed; standard error says what. | | 2 | No arguments; it prints the usage. | With several files, one failure doesn't stop the rest: it's reported as `pktito-cli: talk.mp4: File not found`, and the exit code is 1. ## In scripts ```sh # every recording in a folder, as subtitles beside each pktito-cli -q --srt recordings/*.mp4 # into another folder, as JSON pktito-cli -q --json -o transcripts/ recordings/*.m4a # one file to a variable, stopping on failure text=$(pktito-cli -q interview.wav) || exit 1 ``` In PowerShell: ```powershell pktito-cli -q --srt (Get-ChildItem recordings\*.mp4).FullName if ($LASTEXITCODE) { Write-Error "some files failed" } ``` # For AI agents Source: https://pktito.net/developers/agents How an AI agent can transcribe audio and video with pktito-cli, without a window or questions. `pktito-cli` asks no questions, writes the transcript or JSON to standard output, and reports failures in its exit code and on standard error. Everything runs locally; only the model download reaches the internet. [pktito.net/llms.txt](https://pktito.net/llms.txt) summarizes this page. ## Install `pktito-cli` comes with the app's installers. These addresses always give the latest release: | System | Installer | `pktito-cli` | | ------- | ----------------------------------------------------------------------------------------------- | ---------------------------------------------------- | | macOS | `https://pktito.net/download/macos` | `/Applications/pktito.app/Contents/MacOS/pktito-cli` | | Windows | `https://pktito.net/download/windows` (x64), `https://pktito.net/download/windows-arm64` | On the PATH, in a new terminal | | Linux | `https://pktito.net/download/linux-deb` (x86-64), `https://pktito.net/download/linux-deb-arm64` | `/usr/bin/pktito-cli` | On Linux, install the .deb with apt (`sudo apt install ./pktito_*.deb`) so that ffmpeg, which `pktito-cli` reads files through there, comes with it. ## Transcribe ```sh pktito-cli download parakeet-tdt-0.6b-v2 # once: 624 MB, prints the model's path pktito-cli -q --json talk.mp4 # the transcript, as JSON on stdout ``` `download` retries while the network is away, so give it a time limit. Use `parakeet-tdt-0.6b-v3` (648 MB) for the 25 European languages. Without `--json`, the output is plain text, one sentence a line. The JSON's `segments` hold the sentences, each with `start`, `end`, `text` and its `words`; times are in seconds. [pktito-cli](/developers/cli#json-output) has every field and the exit codes. ## Failures to expect - `no model yet: … pktito-cli download parakeet-tdt-0.6b-v2`: run that download. - `Install ffmpeg to read audio and video here`: on Linux, install ffmpeg. Other messages are explained in [Troubleshooting](/docs/troubleshooting). # The C library Source: https://pktito.net/developers/library libpktito, the C11 library under the app, with what it needs, its API, its backends and how to build it. libpktito is NVIDIA's Parakeet-TDT speech models in C11, the engine under the app, with no Python, PyTorch or ONNX Runtime. It lives at [github.com/peterheb/libpktito](https://github.com/peterheb/libpktito). ## What it needs The C library, libm and pthreads. It builds on Linux, macOS, and Windows 10 and later (with MSYS2's MinGW-w64 gcc). A model is one `.pkf` file, mapped rather than copied: about 650 MB of memory in all while transcribing. ## The API `core/pktito.h` is the whole interface: ```c #include "pktito.h" pk_model *m = pk_model_load("models/parakeet-tdt-0.6b-v2.pkf", err, sizeof err); pk_asr *a = pk_asr_new(m, 0); /* 0: a thread a core */ const pk_tok *t; long n = pk_asr_run(a, samples, n_samples, &t); /* 16 kHz mono float */ pk_text(m, t, (size_t)n, text, sizeof text); /* NeMo's transcript */ /* t[i].frame * pk_model_frame_seconds(m) is when token i was heard */ ``` | Function | What it does | | ----------------------------- | ------------------------------------------------------------------------------- | | `pk_model_load` | Maps a `.pkf` and checks it before anything in it is used. | | `pk_asr_new`, `pk_asr_run` | A transcriber, and 16 kHz mono samples in, tokens with times out. | | `pk_text`, `pk_words` | Tokens to UTF-8 text as NeMo writes it, and to words with their times. | | `pk_vad_probs`, `pk_segments` | Silero VAD's speech probabilities, and the speech segments from them. | | `pk_chunks` | A long recording cut at its silences into pieces the model hears whole. | | `pk_captions` | Words with times to subtitle cues: lines of 42 characters, one or two to a cue. | | `pk_language` | Which of the multilingual model's 25 languages a transcript's words are in. | | `pk_backend` | The backend in use. | A loaded model can be shared across threads; each transcriber belongs to one thread at a time. The library keeps no global state and prints nothing. Recordings longer than about 30 seconds go through `pk_chunks` first. `examples/transcribe.c` is a complete program in one page. ## Backends A build holds every backend for its CPU family, and the fastest one the CPU supports is picked at load time. | Backend | CPUs | | ------------- | ------------------------------------------------------------- | | `neon-dp` | ARMv8.2 with SDOT: Raspberry Pi 5's Cortex-A76, Apple M chips | | `neon` | ARMv8.0: Raspberry Pi 3's Cortex-A53, Pi 4's A72 | | `avx512-vnni` | AVX512-VNNI: Ice Lake, Tiger Lake, Zen 4 | | `avx2-vnni` | AVX-VNNI: Alder Lake and later, Zen 5 | | `avx2` | Haswell and later | | `ref` | Scalar C, for anything | All compute the same bits as `ref`. `PKTITO_KERNELS=neon` forces a backend, to compare. ## Build ```sh make # every backend of this machine's family, and ref make BACKEND=ref # scalar C alone, for anything make libpktito.a # the library alone make check-c # the checks: a compiler and a model, on any board ``` On Windows, the same in an [MSYS2](https://www.msys2.org) UCRT64 shell with `pacman -S make diffutils mingw-w64-ucrt-x86_64-gcc`. The models can be [downloaded](/docs/models) ready to use, or converted from NVIDIA's checkpoints with the repository's converter, which is Python with numpy alone. The README has the steps. ## Agreement with NeMo The repository holds pktito to NeMo at three levels: - **The model**: a float64 reference written from NeMo's code gives NeMo's token ids and timestamps exactly, for both models, on four test recordings in English, German and French. - **The numerics**: pktito multiplies in int8. Against float32 on 200 LibriSpeech recordings, the English model's word error rate is 1.51% for both; on 360 FLEURS recordings in six languages, the multilingual model's is 4.42% against 4.41%. - **The text**: the detokenizer gives NeMo's text on every vocabulary piece and on thousands of random sequences. The [README](https://github.com/peterheb/libpktito) has the method and the machines. # AliceBench Source: https://pktito.net/developers/benchmarks AliceBench v1, one number for how fast a computer transcribes with pktito, and how to run it. ## What it is AliceBench v1 times pktito transcribing LibriVox's public-domain recording of _Alice's Adventures in Wonderland_: twelve chapters, 2:58:51 in all, with the English model (parakeet-tdt-0.6b-v2). The result is the audio's length over the time it took, as times real time. ## Results | Machine | × real time | Whole book | pktito | Backend | Threads | | ---------------------------------------------------------------------------- | ----------: | ---------: | ------ | ----------- | ------: | | Windows Workstation
16 cores, AMD Ryzen 9 9950X | 238.8 | 0:45 | 0.9.1 | avx512-vnni | 16 | | EC2 c8a.xlarge
4 cores, AMD EPYC 9R45 (Zen 5) | 125.9 | 1:25 | 0.9.1 | avx512-vnni | 4 | | Mac mini
12 cores, Apple M4 Pro | 123.0 | 1:27 | 0.9.1 | neon-dp | 12 | | ThinkPad P14s Gen 5 (2024)
8 cores, AMD Ryzen 7 PRO 8840HS | 58.6 | 3:03 | 0.9.1 | avx512-vnni | 8 | | Windows Laptop (2021)
4 cores, Intel Core i7-1185G7 | 37.0 | 4:50 | 0.9.1 | avx512-vnni | 4 | | Raspberry Pi 5
4 cores, Cortex-A76, 4 GB | 14.5 | 12:19 | 0.9.1 | neon-dp | 4 | Run October 24, 2026; every run matched all 12 reference transcripts. The Mac mini was in use at the time. The Windows laptop is a Surface Pro 8, plugged in, in the Balanced power mode; the ThinkPad, a mobile workstation, was plugged in, in the Best performance mode. ## Run it On macOS or Linux, from a clone of [pktito](https://github.com/peterheb/pktito): ```sh scripts/alicebench.sh [DIR] ``` On Windows: ```powershell powershell -ExecutionPolicy Bypass -File scripts\alicebench.ps1 [DIR] ``` It downloads the chapters (200 MB) and the English model the first time, then prints each chapter's speed and the total. - **DIR** defaults to `~/.cache/alicebench-v1`, or `%LOCALAPPDATA%\alicebench-v1` on Windows. - **`PKTITO_CLI`** names the `pktito-cli` to time; otherwise the one on the PATH, or the Mac app's. The full results are saved in DIR as `result.json`. ## Why FLAC The chapters are 16 kHz mono FLAC, made from LibriVox's MP3s, because each system decodes an MP3 slightly differently: macOS's and ffmpeg's versions of chapter 11 differ in 5 of its 1,937 words. A FLAC decodes the same everywhere, so every computer transcribes the same audio. ## “All 12 transcripts are the reference's” Every correct build of pktito writes the same transcript of the same audio, byte for byte, on any machine. So the script also checks each chapter's transcript against the reference. That last line means this build computes the right answer, so its speed counts; a mismatch makes the script exit 1. # Building from source Source: https://pktito.net/developers/building Build the pktito app and pktito-cli from source on macOS, Windows and Linux. The app's source is [github.com/peterheb/pktito](https://github.com/peterheb/pktito). It carries a copy of the C library in `vendor/pktito`, so one clone builds everything. ## What you need - Rust, and the Tauri CLI: ```sh cargo install tauri-cli --version "^2" --locked ``` - A C compiler: - **macOS**: Xcode's command line tools. - **Windows**: MSYS2's MinGW-w64 gcc, with Rust's `x86_64-pc-windows-gnu` toolchain. - **Linux**: gcc or clang. ## macOS and Windows x64 ```sh cargo tauri dev # run it cargo tauri build # the installer ``` `pktito-cli` is built with the app and bundled beside it. ## Windows on Arm Windows on Arm builds on x64 Windows, cross-compiled. You need rustup's `stable-x86_64-pc-windows-gnullvm` toolchain with the `aarch64-pc-windows-gnullvm` target, and [llvm-mingw](https://github.com/mstorsjo/llvm-mingw)'s `bin` folder on the PATH. Its clang compiles and links, and everything is linked statically. ```sh cargo +stable-x86_64-pc-windows-gnullvm build --release --target aarch64-pc-windows-gnullvm ``` The program needs only Windows' own DLLs and the Arm64 `WebView2Loader.dll` beside it. The installer has to name that DLL as a resource, since tauri-bundler 2.10.4 adds it only for targets ending in `-gnu`; without it, the installed app doesn't start: ```sh cargo tauri build --target aarch64-pc-windows-gnullvm --bundles nsis --config \ '{"bundle":{"resources":{"target/aarch64-pc-windows-gnullvm/release/WebView2Loader.dll":"WebView2Loader.dll"}}}' ``` ## Linux ```sh cargo tauri build --bundles deb # the .deb ``` The .deb depends on ffmpeg and recommends xdg-utils, for opening links and folders. ## Formatting The Rust follows rustfmt and the page's JavaScript, CSS, HTML and JSON follow Prettier, each with its defaults. Before a commit: ```sh (cd src-tauri && cargo fmt) npx prettier@3.6.2 --write . ``` `cargo fmt --check` and `npx prettier@3.6.2 --check .` say whether either is due. `.prettierignore` leaves out files that scripts write and the design system's own files. ## The C library `scripts/vendor-pktito.sh` copies the library's sources into `vendor/pktito`, and `vendor/pktito/VENDORED` names the commit. To build the library on its own, see [The C library](/developers/library). # Getting started Source: https://pktito.net/docs/getting-started Install pktito, choose a speech model, and transcribe your first recording. ## Install Download pktito for your system from the [download page](/download). | System | Needs | Installer | | ------- | ---------------------------------------------------------------------------------- | ---------------------------------------------------------- | | macOS | macOS 12 or later, Apple silicon | A disk image: drag pktito to Applications. | | Windows | Windows 10 or 11, x64 or Arm64 | A setup program, which also puts `pktito-cli` on the PATH. | | Linux | glibc 2.34 or later (Ubuntu 22.04, Debian 12, Raspberry Pi OS 12), x86-64 or Arm64 | A .deb, with ffmpeg as a dependency. | Windows N editions need the Media Feature Pack, or ffmpeg, to read audio and video. ## Choose a model On first launch pktito offers two speech models, with the one for your system's language already chosen: - **English**: parakeet-tdt-0.6b-v2, 624 MB. - **Multilingual**: parakeet-tdt-0.6b-v3, 25 European languages, 648 MB. The download can be paused, and resumes where it stopped. To skip it, choose **I already have a model file…**. [Models](/docs/models) has both files. ## Transcribe Drop audio or video files on the window, or click **Choose files…**. The text appears as the recording is transcribed. Several files dropped together are transcribed in turn, as a batch. Finished transcripts stay on the start screen's **Recent** list. ## Read along Press Space to play, or click a sentence's time to play from there. The word being spoken is underlined as the transcript follows along. - **Speed**: < and > change it, from 0.75× to 2×. - **Find**: Ctrl+F (⌘F on a Mac). - **Times**: click the time beside the play button to switch between seconds and frames. [Saving](/docs/saving) covers the formats a transcript can be saved in. # Formats Source: https://pktito.net/docs/formats The audio and video files pktito reads on macOS, Windows and Linux, and with ffmpeg. ## How pktito reads a file pktito reads files with the system's own media library: AVFoundation on macOS, Media Foundation on Windows. Linux uses ffmpeg, which the .deb installs. On macOS and Windows, ffmpeg (when it's installed) reads what the system can't. ## The formats Tested on macOS 27, Windows 11 and Ubuntu 26.04, October 2026. | File | macOS | Windows | ffmpeg | | ------------------------------------------------------------------------- | :---: | :-----: | :----: | | MP4, MOV, M4A, 3GP: AAC, HE-AAC v1 and v2, ALAC, PCM; H.264, HEVC, ProRes | ✓ | ✓ | ✓ | | MP3, constant and variable rate | ✓ | ✓ | ✓ | | WAV: 16 and 24-bit, float, µ-law, IMA ADPCM | ✓ | ✓ | ✓ | | FLAC, 16-bit 44.1 kHz and 24-bit 96 kHz | ✓ | ✓ | ✓ | | MPEG-TS (H.264, AAC), MPEG-PS (MPEG-2, MP2) | ✓ | ✓ | ✓ | | AVI: MJPEG with PCM | ✓ | ✓ | ✓ | | AC-3 5.1, alone or in M2TS | ✓ | – | ✓ | | AIFF; CAF with ALAC | ✓ | – | ✓ | | Ogg Opus and Vorbis, .opus voice messages | ✓ | – | ✓ | | WebM: Opus or Vorbis, with VP8, VP9 or AV1 | – | ✓ | ✓ | | Matroska with AAC | – | ✓ | ✓ | | Matroska with AC-3, E-AC-3 or DTS 5.1 | – | – | ✓ | | WMA, WMV | – | ✓ | ✓ | | AVI: MPEG-4 with MP3 | – | ✓ | ✓ | | FLV; Ogg Theora | – | – | ✓ | A file with several audio tracks gives its first. ## The same transcript everywhere A lossless file (WAV, FLAC, ALAC) gives the same transcript on every system. A lossy one can differ by a word or two, since each system decodes it slightly differently. ## Choosing the reader `PKTITO_DECODER` overrides the choice, for the app and `pktito-cli`: - `PKTITO_DECODER=ffmpeg` reads everything through ffmpeg. - `PKTITO_DECODER=os` uses the system alone, never ffmpeg. # Models Source: https://pktito.net/docs/models The two speech models pktito uses, where to download them, and how to use a model file you already have. ## The two models | Model | Transcribes | Download | | -------------------- | --------------------- | -------- | | parakeet-tdt-0.6b-v2 | English | 624 MB | | parakeet-tdt-0.6b-v3 | 25 European languages | 648 MB | The multilingual model covers Bulgarian, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hungarian, Italian, Latvian, Lithuanian, Maltese, Polish, Portuguese, Romanian, Russian, Slovak, Slovenian, Spanish, Swedish and Ukrainian. Its [model card](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3#multilingual-asr) gives the accuracy for each. Switch models from the model menu on the start screen. ## Downloads pktito checks each download against the size and SHA-256 below. A file's address holds the start of its SHA-256, so it never changes. ### parakeet-tdt-0.6b-v2 - Size: 624,480,196 bytes - SHA-256: `8bfa6750b83cd7c447bad82057c7a12473563b72b3d35487fcca6da0786d83c7` - [https://models.pktito.net/8bfa6750b83c/parakeet-tdt-0.6b-v2.pkf](https://models.pktito.net/8bfa6750b83c/parakeet-tdt-0.6b-v2.pkf) ### parakeet-tdt-0.6b-v3 - Size: 647,552,644 bytes - SHA-256: `35a59c9a433d4da2289640db93e73c42478b576e49a293090ef61b4ae595152a` - [https://models.pktito.net/35a59c9a433d/parakeet-tdt-0.6b-v3.pkf](https://models.pktito.net/35a59c9a433d/parakeet-tdt-0.6b-v3.pkf) To check a file by hand: `shasum -a 256` on macOS, `sha256sum` on Linux, `Get-FileHash` in Windows PowerShell. ## Using a model file you already have - **In the app**: choose **Open a model file…** from the model menu on the start screen, or **I already have a model file…** on the first run. Double-clicking a `.pkf` also opens pktito with it in use. - **In pktito-cli**: `-m` takes the file's path, as in `pktito-cli -m /path/to/parakeet-tdt-0.6b-v2.pkf talk.mp4`. See [pktito-cli](/developers/cli). If pktito can't load the file, the model in use stays as it was; [Troubleshooting](/docs/troubleshooting#model-files) explains the message. ## Attribution The models are NVIDIA's [parakeet-tdt-0.6b-v2](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v2) and [parakeet-tdt-0.6b-v3](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3), under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/), modified by pktito (partly quantized to int8). Each file also holds Silero VAD (MIT), which finds the pauses in long recordings. pktito is not affiliated with or endorsed by NVIDIA. # Saving Source: https://pktito.net/docs/saving Save a transcript as text, subtitles, Markdown or JSON, save a whole batch at once, or copy it. ## Save as | Format | File | What it holds | | ---------------------- | ------- | ----------------------------------------------------------------- | | Text | `.txt` | The sentences, one to a line. | | Subtitles | `.srt` | Numbered cues with their start and end times. | | Web subtitles | `.vtt` | The same cues as WebVTT. | | Markdown | `.md` | The file's name as a heading, then a paragraph for each sentence. | | JSON with word timings | `.json` | The sentences, every word's start and end, and the subtitle cues. | **Timestamps in .txt and .md**, at the bottom of the menu, puts each sentence's start time before it. Ctrl+S saves as text and Ctrl+Shift+S as subtitles (⌘S and ⌘⇧S on a Mac). `pktito-cli` writes the same files; [its reference](/developers/cli#json-output) lists the JSON's fields. ## Where it goes With **Save next to the original** checked, the transcript is saved beside the original. Otherwise a dialog asks. pktito never writes over a file: a second `talk.txt` becomes `talk 2.txt` (`talk (2).txt` on Windows). ## Save all A batch has **Save all**: text or subtitles next to each original, or every format into one folder. Files still being transcribed are saved as each one finishes. ## Copy The copy button copies the text, or in the Captions view the cues as SRT. While a file is still being transcribed, it copies the text so far. ## Sentences and captions A finished transcript can show its **Sentences**, as the model wrote them, or its **Captions**: the subtitle cues, one or two lines of at most 42 characters each. A cue that asks more than 20 characters a second of its reader is marked. # Troubleshooting Source: https://pktito.net/docs/troubleshooting What pktito's messages mean, and what to do about them. A message's **Details**, or its tooltip, has what the system or the server said. Include it when [reporting a problem](https://github.com/peterheb/pktito/issues). ## Reading a file | Message | What to do | | ------------------------------------------------- | ------------------------------------------------------------------------------------ | | File not found | The file was moved or deleted after it was added. Add it again from where it is now. | | Not audio or video | The file isn't a recording, whatever its name says. | | No audio track | The video has no sound. | | Can't read this file. Installing ffmpeg may help. | Install ffmpeg; [Formats](/docs/formats) shows which formats need it. | | Can't read this file | The file may be damaged. | | Install ffmpeg to read audio and video here | On Linux: `sudo apt install ffmpeg`. | | Couldn't start ffmpeg | Check that `ffmpeg -version` works in a terminal, or reinstall ffmpeg. | | Can't convert this audio | Convert the file to WAV or MP3. | ## Downloading the model Network errors (**Can't reach models.pktito.net**, **Connection lost**, **isn't answering**) are retried automatically, and the download resumes where it stopped. | Message | What to do | | ---------------------------------- | ---------------------------------------------------------------- | | The download was damaged | Choose **Try again**. | | Not enough disk space | Free about 650 MB and choose **Try again**. | | Couldn't save the model | pktito can't write to its data folder; Details names the folder. | | Model not found | [Report it](https://github.com/peterheb/pktito/issues). | | … is downloading. Cancel it first. | Cancel the other download, or wait for it to finish. | ## Model files | Message | What to do | | -------------------------------- | ------------------------------------------------------------------------ | | Choose a model first | Choose one from the model menu on the start screen. | | Needs a newer version of pktito | Update pktito. | | Not a pktito model | The file isn't a `.pkf` model. | | Model file incomplete or damaged | Download it again, and check its SHA-256 against [Models](/docs/models). | ## Transcribing and playback | Message | What to do | | ------------------------------------------------------------------ | ----------------------------------------------------------------- | | Not enough memory. Close other apps and try again. | Transcribing takes about 700 MB. Then choose **Start again**. | | Can't play: the original file was moved or deleted | Put the original back, or transcribe it again from its new place. | | Can't play: the original file has changed since it was transcribed | Transcribe it again. | ## Linux | Message | What to do | | ---------------------------------------------------------------- | ---------------------------- | | Install xdg-utils to open links, Install xdg-utils to show files | `sudo apt install xdg-utils` | ## Install Command Line Tool on a Mac | Message | What to do | | ----------------------------------------------------- | ------------------------------------------ | | Installed pktito-cli in /usr/local/bin | Open a new terminal and run `pktito-cli`. | | pktito-cli is missing from the app. Reinstall pktito. | Download pktito again and replace the app. |