Most meeting assistants require users to invite bots to join meetings or upload sensitive business conversations to the cloud. Nojoin offers a different approach.

• Privacy First: Audio and transcripts remain on the user's server (unless explicitly configured for external LLM processing).
• Unlimited: No monthly limits on recording minutes.
• Smart: Utilizes OpenAI Whisper (Turbo) for transcription and Pyannote for speaker identification.
• Interactive: Enables chat with meetings using ChatGPT, Claude, Gemini, or Ollama.
• Non-Intrusive: Nojoin does not require joining meetings as a participant.

• Why Nojoin?
• Quick Start
• Hardware Requirements
• Features
• System Architecture
• API Keys & Configuration
• User Management
• Installation & Setup
• Updating Nojoin
• Troubleshooting
• Roadmap
• Contributing
• Editions
• Legal

1. Clone: git clone https://github.com/Valtora/Nojoin && cd Nojoin

2. Launch: docker compose up -d (Pulls pre-built images from GHCR)

3. Use: Open https://localhost:14443 (Accept self-signed cert warning)

4. Configure: Follow the first-run wizard to set up API keys and preferences.

5. Companion App: Navigate to the Releases page to download, install, and connect the companion app on client machines to start recording audio.

   • See Installation & Setup for CPU-only mode and configuration details.

• Backend Server:
  • Recommended: Windows 11 (with WSL2) or Linux system with a compatible NVIDIA GPU (CUDA 12.x support).
  • Minimum: 8GB VRAM for optimal performance (Whisper Turbo + Pyannote).
  • macOS Hosting: Hosting the backend on macOS via Docker is not recommended.
    • Docker on macOS cannot pass through the Apple Silicon GPU (Metal) to containers. This forces the system to run in CPU-only mode, which is significantly slower for transcription and diarization.
• Companion App:
  • Currently supported on Windows only.
  • macOS and Linux companion apps are not yet available. Contributors are welcome to help build support for these platforms!

• Distributed Architecture:
  • Server: Dockerized backend handling heavy AI processing (Whisper, Pyannote).
  • Web Client: Modern Next.js interface for managing meetings from anywhere.
  • Companion App: Lightweight Rust system tray app for capturing audio on client machines.
• Advanced Audio Processing:
  • Local-First Transcription: Uses OpenAI's Whisper (default Turbo) for accurate, private transcription.
  • Speaker Diarization: Automatically identifies distinct speakers using Pyannote.
  • System Audio Capture: Captures both system audio out and microphone input.
• Meeting Intelligence:
  • LLM-Powered Notes: Generate summaries, action items, and key takeaways using OpenAI, Anthropic, Google Gemini, or Ollama.
  • Chat Q&A: "Chat with your meeting" to ask specific questions about the content or make edits to notes.
  • Documents: Upload documents to be processed by the LLM.
  • Cross-Meeting Context: Select tags to include meetings, notes, and documents from across all meetings with the same tag(s).
• Organization & Search:
  • Global Speaker Library: Centralized management of speaker identities across all recordings.
  • Full-Text Search: Instantly find content across transcripts, titles, and notes.
  • Tagging: Organize meetings with custom tags.
• User Management & Security:
  • Role-Based Access: Owner, Admin, and User roles with granular permissions.
  • Invitation System: Secure registration via invite links with expiration and usage limits.
  • User Data: Complete data cleanup on user deletion (files, database records, and logs).

Nojoin is composed of three distinct subsystems:

1. The Server (Dockerized):

   • Hosted on a machine with NVIDIA GPU capabilities.
   • Runs the API (FastAPI), Worker (Celery), Database (PostgreSQL), and Broker (Redis).
   • Handles all heavy lifting: VAD, Transcription, and Diarization.

2. The Web Client (Next.js):

   • The primary interface for users.
   • Provides a dashboard for playback, transcript editing, and system configuration.

3. The Companion App (Rust):

   • Runs on Windows client machines.
   • Sits in the system tray and handles audio capture.
   • Uploads audio to the server for processing.
   • Platform Support: Currently Windows-only. Community contributions are welcome for macOS and Linux support!

Nojoin requires certain API keys to function fully. The first-run wizard will request these keys, but they can also be entered in the Settings -> AI Services page of the web interface after installation.

To enable speaker diarization (identifying who is speaking), a Hugging Face token is required.

Privacy Note: This token is only used to download the model weights from Hugging Face. All audio processing and diarization happens locally on the server. No audio data is sent to Hugging Face.

1. Create an account on Hugging Face.
2. Generate an Access Token. A token with fine-grained permissions can be used:
   • Select "Read access to contents of selected repos".
   • Select the following repositories:
     • pyannote/speaker-diarization-community-1
     • pyannote/wespeaker-voxceleb-resnet34-LM
3. Accept the user conditions for the following models:
   • pyannote/speaker-diarization-community-1
   • pyannote/wespeaker-voxceleb-resnet34-LM
4. Enter this token in the Nojoin Settings > AI Settings.

To use the meeting note generation, speaker/title inference, and meeting chat features, an API key from one of the supported providers is required.

Privacy Note: If cloud-based LLM providers (OpenAI, Anthropic, Google Gemini) are used, meeting transcripts and notes will be sent to their API for processing. To keep everything 100% local, use Ollama.

• OpenAI
• Anthropic
• Google Gemini
• Ollama (Local LLMs - no API key required, but requires setup)

Nojoin includes a robust user management system designed for self-hosted environments.

• Owner: The first user created is automatically assigned the Owner role. Has full system access and cannot be deleted.
• Admin: Can manage users, create/revoke invites, and view system settings.
• User: Standard access to record and manage their own meetings.

Registration is restricted to invited users only.

1. Create Invite: Admins generate invite links with specific roles (Admin/User), expiration dates, and usage limits.
2. Revoke: Invites can be revoked at any time to prevent further signups while keeping a record of the code.
3. Delete: Revoked invites can be permanently deleted from the system.

When a user is deleted, Nojoin performs a hard delete of all associated data to ensure privacy:

• Files: Audio recordings and proxy files are physically removed from the disk.
• Database: User account, recordings, transcripts, chat history, and speaker profiles are cascaded and removed.
• Anonymization: Invitations created by the deleted user are preserved but anonymized (orphaned) to maintain invite code validity for other users.

• Docker Desktop (Windows/Mac) or Docker Engine (Linux)
• NVIDIA GPU (Optional, but highly recommended for faster processing).
  • Requires NVIDIA Container Toolkit to be installed on Linux.
  • Compute Capability 6.1+ (Pascal) recommended.

If you plan to develop or build Nojoin from source, you will need the following tools installed:

General:

• Git
• Docker (Required for running Database and Redis services)

Backend (Python):

• Python 3.11
• FFmpeg (Required for audio processing)
  • Linux: sudo apt install ffmpeg
  • Windows: Download and add to PATH.
• PostgreSQL Development Headers
  • Linux: sudo apt install libpq-dev
• Compiler Tools
  • Linux: sudo apt install build-essential
  • Windows: Microsoft Visual C++ Build Tools

Frontend (Node.js):

• Node.js v20+ (LTS recommended)
• npm (comes with Node.js) or pnpm

Companion App (Rust):

• Rust (Latest Stable)
• CMake (Used by some Rust build scripts)
• Platform-specific dependencies:
  • Linux: sudo apt install libwebkit2gtk-4.0-dev build-essential curl wget file libssl-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev
  • Windows: Microsoft Visual C++ Build Tools

1. Clone the repository:

   git clone https://github.com/Valtora/Nojoin
   cd Nojoin

2. Start the Stack:

   Option A: NVIDIA GPU (Default) Requires an NVIDIA GPU. Much faster processing.

   docker compose up -d

   Note: This pulls pre-built images from GitHub Container Registry. To build from source, use docker compose up -d --build.

   Option B: CPU Works on all systems. Slower processing speeds.

   Open docker-compose.yml and comment out the deploy section under the worker service.

   Then run:

   docker compose up -d

   Note: The first run may take several minutes as it needs to download large Docker images.

3. Access the Application:

   • Web Interface: Open https://localhost:14443
     • Note: A "Not Secure" warning will appear because of the self-signed certificate.
   • Remote Access: The Docker images are pre-configured to work on any domain. Simply access the server via its IP or domain name (e.g., https://192.168.1.50:14443).
     • Note: The domain may need to be added to ALLOWED_ORIGINS in .env if CORS issues are encountered.

If running Ollama on the same machine as the Nojoin Docker containers, the special Docker host address must be used:

• API URL: http://host.docker.internal:11434
• Do not use localhost or 127.0.0.1 as the container cannot see the host's localhost.

1. Go to the Releases page.
2. Download the Windows installer (Nojoin_X.Y.Z_windows.exe). There is also a portable binary available if preferred.
3. Run the installer. The application will appear in the system tray.
4. The web app also has a 'Download Companion App' button that will direct to the releases page.

Note: For developers, the app can be built from source by navigating to the companion directory and running cargo build --release on Windows.

🤝 Contributions Welcomed: Contributions are welcomed to help build macOS and Linux versions of the companion app. The Windows version uses standard Rust audio libraries (cpal) that have cross-platform support for Linux so I will focus on this first. MacOS is trickier due to the need to use ScreenCaptureKit for system audio capture. If interested in contributing, please check the Contributing Guide or open an issue to discuss.

To update Nojoin to the latest version, in the Nojoin directory:

1. Stop the containers:

   docker compose down

2. Pull the latest images:

   docker compose pull

3. Start the containers:

   docker compose up -d

Note: You can check your current version and view if a new version is available directly on the Settings page.

Release Strategy: Docker images (ghcr.io/valtora/nojoin-*) are automatically built and updated with every push to the main branch. GitHub Releases are generally reserved for updates to the Companion App binaries or major codebase milestones. If you want the absolute latest features, simply pull the latest Docker images.

• Windows Support (Stable)
• macOS & Linux Support (Contributions Welcome)
  • Community-driven development for companion app.
    • Windows implementation can serve as a reference.
• Real-time Transcription (Target: Q2 2026)
  • Live transcript generation during recording.
  • Instant feedback loop.
  • Real-time suggestions and notes.

Contributions from the community are welcome! Whether it's fixing bugs, improving documentation, or adding new features, help is appreciated.

Important: To ensure Nojoin can remain sustainable and offer a commercial SaaS version, by submitting a Pull Request, you agree to the Contributor License Agreement (CLA). This grants Valtora the right to use your contributions in the commercial version of the platform while ensuring the Community Edition remains open source forever.

Please see the Contributing Guide for details on how to get started.

• Community Edition: The source code in this repository. Free, open-source (AGPLv3), and self-hosted. Ideal for individuals, developers, and privacy-focused users who want full control over their data.

• Nojoin Cloud: A fully managed, hosted version of Nojoin allowing users to take advantage of powerful GPUs and pay a monthly subscription based on tiered usage. (Coming Late 2026)

The Community Edition of Nojoin is licensed under the GNU Affero General Public License v3.0 (AGPLv3). This ensures that the software remains free and open-source, and that any modifications made to the code (even if run as a service) must be shared back with the community.

The Nojoin Cloud (SaaS) edition is a proprietary, closed-source service provided by Valtora.

This project utilizes the following third-party models and libraries:

• Pyannote Audio models (pyannote/speaker-diarization-community-1 and pyannote/wespeaker-voxceleb-resnet34-LM) by Pyannote. Licensed under Creative Commons Attribution 4.0 International (CC BY 4.0).
• OpenAI Whisper by OpenAI. Licensed under the MIT License.

Please review the Legal Disclaimer regarding the recording of conversations and compliance with local laws.

If Nojoin is useful, please consider buying me a coffee as a way to support Nojoin.