Engineering Deep Dive
Under the Hood
A detailed look at how Meow delivers native performance, crystal-clear audio, and rock-solid SIP connectivity, all in a lightweight package.
Layered Architecture
Five cleanly separated layers with one-way dependencies. Each layer only talks to the one directly below it.
Audio Pipeline
Custom audio backend built for VoIP. Not a generic media player repurposed for calls.
A device PJSIP owns, not a media player
Meow registers its own pjmedia_aud_dev_factory and drives it through the PulseAudio client API, which pipewire-pulse serves. PipeWire 0.3.50 or newer is required, and ships as standard on every supported distribution.
48 kHz, one call frame per buffer
Mono S16 at 48 kHz, with the buffer target set to a single 20 ms PJSIP frame — 960 samples. The rate matches the sound server's own graph, so nothing resamples in the middle of a call.
The sound server matches the clock
Streams open with PA_STREAM_ADJUST_LATENCY, so rate matching is the server's job rather than a free-running clock in the client. Getting that backwards is what produces the drift and robot voice that plague softphones across distributions.
The microphone closes between calls
Streams are created when a call starts and released eight seconds after the last one ends. Your desktop's recording indicator is lit while you are on a call, not for as long as Meow is running.
Audio Pipeline Configuration
─────────────────────────────
Sample rate: 48 kHz
Channels: Mono (S16LE)
Frame: 960 samples (20 ms)
Buffering: PA_STREAM_ADJUST_LATENCY
Stream role: media.role = phone
Lifetime: per call, released after 8 s idle
Platform backends:
Linux → libpulse → pipewire-pulse (>= 0.3.50)
PJSIP ALSA if libpulse is unreachable
Windows → WASAPI shared mode (eCommunications)
WMME fallbackSIP & Call Management
State-machine-driven call handling with thread-safe PJSIP integration.
QStateMachine FSM
Single source of truth for call state. Transitions are atomic and thread-safe via Qt signal/slot.
Thread-Safe PJSIP
PJSIP runs on background threads; all callbacks are safely marshaled to the Qt UI thread, preventing race conditions and ensuring smooth UI updates.
DTMF (RFC 2833)
RFC 2833 DTMF digit transmission for IVR navigation. Compatible with all major PBX systems.
Call Recording
Record calls to WAV files on demand or automatically. Recordings are stored locally with per-call metadata and can be played back from the call history.
Contact Enrichment
Incoming calls are matched against contacts using phone number normalization with country code awareness.
Security & Licensing
Cryptographically sound licensing with hardware-bound activation.
Hardware Fingerprinting
An anonymous, multi-factor hardware fingerprint uniquely identifies each device. The fingerprint is stable across reboots and cannot be used to identify you personally.
Cryptographic Signatures
License tokens are cryptographically signed by the server. The client verifies them offline using an embedded certificate, so no network is needed for validation.
Anti-Reset Protection
Server-side hardware matching prevents trial resets. Reinstalling the OS or clearing local storage won't grant a new trial: the server remembers your device.
Voice Encryption
SRTP media encryption is supported and negotiated automatically when the SIP server supports it. TLS is available for signaling encryption.
Performance
Native code means native performance. No runtime overhead, no garbage collector pauses.
Memory Comparison (typical idle call)
Application memory. Figures for other clients are typical published values, not our own measurements.
Where the memory goes
A task manager will show a larger number than 50 MB, so here is the whole picture. Roughly 50 MB is Meow. The rest is the graphics driver and the toolkit, which every desktop application pays for and mostly shares with the other programs you are running.
| Component | Resident | Proportional |
|---|---|---|
| Application memory (heap)Meow's own allocations | 50 MB | 50 MB |
| GPU driver stackshared with every GPU client | 77 MB | 37 MB |
| Qt, bundled in the AppImageshared from a .deb or .rpm | 39 MB | 39 MB |
| Anonymous buffersQt scene graph, QML engine | 12 MB | 12 MB |
| Other bundled librariesPJSIP, OpenSSL, SQLite | 12 MB | 12 MB |
| System librariesglibc and friends | 19 MB | 5 MB |
| meow-sip binarythe executable itself | 7 MB | 7 MB |
| Fonts and other files | 5 MB | 4 MB |
| Total | 222 MB | 167 MB |
Resident counts a shared page once for every program using it. Proportional divides it between them, so it is the fairer figure for what Meow costs your machine.
Measured on the release AppImage, idle and registered, on Fedora with an NVIDIA GPU. The .rpm build measures the same to within a megabyte: every package bundles its own Qt, so the format you install makes no difference to this table.
The graphics row is the one that moves. It is an NVIDIA driver here; with no GPU driver at all, the same build sits at 134 MB resident rather than 222 MB. A lighter driver lands somewhere between the two, and none of that difference is Meow.
Each row is rounded to the nearest megabyte, so the rows sum to within 1 MB of the totals rather than exactly.
Platform Support
Truly native on each platform. Not a cross-platform wrapper with platform quirks.
Windows
Fully SupportedLinux
Fully SupportedStandards & Compatibility
Built on PJSIP, the most widely deployed open-source SIP stack. Standards-first, vendor-agnostic.
SIP: Session Initiation Protocol
RTP: Real-Time Transport Protocol
DTMF Tones via RTP Payloads
SRTP: Secure Real-Time Transport
SIP: Locating SIP Servers
SIP Outbound Connections
Tested PBX Systems
Ready to experience a truly native SIP client?
Start 14 Days Free Trial