Parlor

Quick Verdict

Parlor is a compact research project for developers who want to experiment with real-time voice and vision conversations on a controlled machine. The browser captures microphone audio and camera frames, sends audio plus JPEG images over a WebSocket to a FastAPI process, and receives transcript text and streamed speech in return. Gemma 4 E2B handles multimodal understanding through LiteRT-LM, while Kokoro produces speech locally. The repository uses Apache 2.0 and explicitly calls the project a research preview with rough edges and bugs. As of July 21, 2026, it has no formal GitHub release. The 0.1.0 value in pyproject.toml is project metadata, not evidence of a stable published release.

The phrase “on device” depends on topology. The current server starts on 0.0.0.0, and its /ws endpoint accepts a connection without application login, bearer-token validation, or an explicit Origin allowlist. If port 8000 is exposed through a LAN interface, container mapping, tunnel, or public gateway, another client may be able to submit media and consume model resources. The frontend also inserts model responses and transcriptions with innerHTML instead of escaping them first, creating a DOM XSS risk when text contains markup. Google Fonts and scripts from jsDelivr are loaded by default, including ONNX Runtime Web and the browser VAD bundle, so the standard page is not fully offline. Parlor is suitable for isolated local research, not direct multi-user deployment.

Best For

• Developers studying how browser media capture, voice activity detection, multimodal inference, and streamed speech fit together.
• Owners of Apple Silicon hardware or Linux machines with a compatible GPU who can manage model runtimes.
• Researchers prototyping language practice, object description, accessibility interaction, or local multimodal interfaces.
• Technical users willing to inspect source, pin a commit, add controls, and tolerate preview-stage failures.
• Teams that want a small reference implementation rather than a complete account, policy, monitoring, and deployment platform.
• Not ideal for nontechnical users, organizations requiring a supported release, or anyone planning to expose the default server to untrusted clients.

Key Features

The browser requests microphone and camera permission, records speech at 16 kHz, and captures a compressed camera frame when an utterance ends. Silero VAD runs in the browser to detect speech boundaries without push-to-talk. When the user speaks while audio is playing, the client can signal an interruption. The FastAPI server combines the audio, image, and a short instruction in a per-connection Gemma conversation, then returns a transcription and brief response.

Speech generation is split by sentence. Kokoro renders each sentence, the server converts it to 16-bit PCM, and WebSocket messages carry successive base64 audio chunks back to the browser. macOS uses an MLX-oriented speech backend; Linux uses an ONNX-oriented path. The model file is downloaded automatically on first run unless MODEL_PATH points to an existing copy. The repository says the Gemma file is about 2.6 GB and suggests roughly 3 GB of free RAM for the model, although the full Python process, browser, graphics runtime, and speech backend require additional resources.

The published Apple M3 Pro reference is about 1.8 to 2.2 seconds for speech and vision understanding, around 0.3 seconds for a short response, and 0.3 to 0.7 seconds for speech synthesis. Total end-to-end time is listed as roughly 2.5 to 3.0 seconds. That is a useful local conversational prototype, but it should replace earlier descriptions claiming a complete sub-second turn.

Use Cases

The safest trial runs the browser and server on the same trusted machine and opens http://localhost:8000. That setup supports language-speaking exercises, descriptions of objects shown to the camera, hands-free interface experiments, and measurements of local multimodal latency. Developers can modify the short code path to study barge-in behavior, sentence streaming, VAD thresholds, and different local model files.

Moving the browser to another device changes the security and privacy model. Audio, camera images, transcriptions, and generated responses cross a network boundary. A real remote deployment needs TLS, authenticated sessions, an Origin policy, narrow network exposure, and clear permission indicators. Simply publishing port 8000 is not a deployment plan. The camera toggle in the current page controls whether a frame is attached to a message; browser-level media permission remains the authority users should manage.

Resource abuse is another concern. The current WebSocket path does not show explicit limits for message size, connection count, request rate, or media duration. Each accepted connection creates conversation state and can trigger CPU, GPU, memory, and TTS work. Oversized base64 audio, frequent images, repeated reconnects, or concurrent sessions may exhaust the host. Put hard limits and timeouts before the model process, reject malformed inputs early, and monitor GPU memory and queue depth.

The frontend must also treat both transcription and model output as untrusted text. Its addMessage function currently constructs HTML and assigns it to innerHTML. A transcription or response containing HTML can therefore affect the page rather than appearing only as text. Replace this path with textContent or a carefully configured sanitizer, and add a restrictive Content Security Policy before testing with untrusted users or model inputs.

Pricing

Parlor’s repository code is free under Apache 2.0, with no project subscription. The operating cost is the compatible machine, electricity, storage, model downloads, and engineering time. Local inference avoids per-request model API charges, but preview software can create substantial maintenance cost when GPU backends, Python dependencies, browser behavior, or model formats change.

There is no formal release as of July 21, 2026. Pin a commit for every experiment or deployment review. The Python constraint in src/pyproject.toml is exact: >=3.12,<3.13. Use Python 3.12; the shorter “Python 3.12+” wording in the README does not remove the upper bound, and Python 3.13 is outside the declared range.

Apache 2.0 applies to the Parlor repository, not automatically to every dependency or model asset. Gemma weights and access terms, Kokoro components, Silero VAD, LiteRT-LM, ONNX Runtime, browser libraries, and fonts each have their own notices or terms. Review them individually before redistribution or commercial use. Also retain required notices when packaging third-party assets locally.

Pros

• The browser-to-server-to-model data path is small enough to understand and modify.
• Voice, camera, VAD, interruption, transcription, and sentence-level speech form a complete interaction prototype.
• Multimodal inference and speech synthesis can run on the local machine without metered model requests.
• Apache-2.0 repository licensing provides a clear code baseline.
• The project publishes stage-by-stage M3 Pro timing rather than relying only on a vague “real-time” label.
• Apple Silicon and compatible Linux GPU paths cover two useful local development environments.
• Per-connection conversation state gives each browser session a separate model context during the connection.

Cons

• It is explicitly a research preview with no formal release, compatibility guarantee, or production support.
• The declared Python range is limited to >=3.12,<3.13.
• Uvicorn binds to 0.0.0.0, while the WebSocket lacks application authentication and an explicit Origin allowlist.
• Model responses and transcriptions are inserted with innerHTML, creating a DOM XSS risk.
• Default Google Fonts and jsDelivr dependencies weaken offline operation and add supply-chain and availability boundaries.
• The page does not show Subresource Integrity attributes or a restrictive Content Security Policy for those assets.
• Explicit message-size, connection-count, and rate controls are absent from the current WebSocket handler.
• Base64 media and per-session inference can consume memory, CPU, GPU, and speech resources quickly under concurrent or abusive traffic.
• Local repository licensing does not make all models, voices, libraries, and fonts Apache-licensed.
• Camera data stops being device-local as soon as the browser talks to a server on another host.

Alternatives

FAQ

Is Parlor a stable product?

No. The repository labels it a research preview and warns users to expect rough edges and bugs. It had no formal GitHub release on July 21, 2026.

Which Python version should Parlor use?

Use Python 3.12. The authoritative project constraint is >=3.12,<3.13, so Python 3.13 is outside the declared supported range even though the README uses the shorter phrase “3.12+.”

Is Parlor completely offline?

Inference and speech synthesis can run locally, but the default page fetches fonts and VAD-related JavaScript from external CDNs, and the first run downloads model assets. Strict offline use requires prefetching models and serving all browser assets locally.

Can I expose port 8000 to other users?

Do not expose the default service directly. It binds to all interfaces, and the current WebSocket path lacks a complete authentication, Origin, size, and rate-control layer. Add a secured TLS entry point, identity, network restrictions, input limits, and monitoring first.

Why do the model and dependency terms need separate review?

Apache 2.0 covers the Parlor repository under its terms. It does not rewrite the licenses or usage conditions for Gemma, Kokoro, Silero VAD, LiteRT-LM, ONNX Runtime, CDN packages, or fonts. Distribution and commercial use require a component-by-component review.

Bottom Line

Parlor is a readable and useful local voice-and-vision experiment, not a secure multi-user runtime out of the box. Pin a commit, use Python 3.12, run the browser and service on the same trusted machine through localhost, and review every model and dependency term. If media crosses to another host, document and protect that network boundary. Before any shared deployment, address the unauthenticated WebSocket, missing Origin and resource controls, innerHTML injection, external CDN assets, and denial-of-service exposure. Until then, keep the project inside an isolated research environment.