[opensourcedex]

Jan is a free, open source ai interaction & interfaces project written in TypeScript and released under a custom open-source licence. It has 44,512 GitHub stars, 3,032 forks and 521 open issues, and was last pushed 8 hours ago. On this registry it ranks #8 of 76 tracked projects in AI Interaction & Interfaces, with 5 head-to-head comparisons available. It gained 71 stars over the last 6 tracked days.

Jan — Run AI models locally or connect to cloud, privately

What is Jan?

What it is

Jan is an open-source desktop application that serves as a ChatGPT replacement, enabling users to run large language models (LLMs) locally on their machines or connect to cloud-based providers like OpenAI and Anthropic. It is built with Tauri, TypeScript, and integrates llama.cpp for efficient local inference, targeting privacy-conscious users who want full control over their AI workflows without sending data to third parties.

The project solves the problem of accessibility and control: users can download and run models such as Llama, Gemma, Qwen, and GPT-oss directly from Hugging Face, with no requirement to rely on proprietary APIs or cloud services for basic usage. It bridges the gap between raw model deployment tools (like llama.cpp CLI) and user-friendly interfaces, offering a GUI for model management, chat, and configuration while retaining the flexibility to expose an OpenAI-compatible API for integration with other tools.

Key capabilities

  • Run LLMs locally using llama.cpp backend with support for CPU, Metal, Vulkan, CUDA, and ROCm acceleration
  • Connect to cloud models via OpenAI, Anthropic, Mistral, Groq, MiniMax, and other providers through unified configuration
  • Create and manage custom AI assistants with distinct system prompts and model assignments
  • Expose a local OpenAI-compatible API server on localhost:1337 for programmatic access
  • Integrate Model Context Protocol (MCP) for extended agentic behaviors
  • Import and export chat sessions and assistant configurations via JSON
  • Switch between local and cloud models dynamically within the same interface

Who uses it and how

  • Developers run local LLMs for prototyping or testing without exposing data to external services
  • Privacy-focused users deploy models on personal hardware to avoid third-party data collection
  • Researchers and educators use Jan as a self-hosted interface for experimenting with open models across platforms (macOS, Windows, Linux)
  • Teams integrate Jan’s local API endpoint into internal tooling or scripts requiring offline LLM access

Getting started

Download prebuilt binaries (.exe, .dmg, .deb, .AppImage) from jan.ai or GitHub Releases; alternatively, build from source using make dev after installing Node.js ≥20, Yarn ≥4.5, Rust, and platform-specific toolchains. No hosted option is provided—Jan is strictly a client-side application.

When to use it — and when not to

Use Jan when you need a local-first, open-source interface for LLMs with minimal vendor lock-in and want to avoid recurring API costs or data leakage. Avoid it if you require managed infrastructure, enterprise support, or seamless scaling beyond single-machine capabilities—Jan does not include clustering, multi-user authentication, or centralized model hosting. Running large models demands sufficient RAM (e.g., 16GB+ for 7B models), and GPU acceleration requires manual setup for CUDA or ROCm.

project readme (upstream, from github) — read inline

Jan - Open-source ChatGPT replacement

github jan banner

English · 中文 · 日本語

GitHub commit activity Github Last Commit Github Contributors GitHub closed issues Discord

Getting Started - Community - Changelog - Bug reports

Jan is bringing the best of open-source AI in an easy-to-use product. Download and run LLMs with full control and privacy.

Installation

Get it from Microsoft Store Get it on Flathub

The easiest way to get started is by downloading one of the following versions for your respective operating system:

Platform Download
Windows jan.exe
macOS jan.dmg
Linux (deb) jan.deb
Linux (AppImage) jan.AppImage
Linux (Arm64) How-to

Download from jan.ai or GitHub Releases.

Features

  • Local AI Models: Download and run LLMs (Llama, Gemma, Qwen, GPT-oss etc.) from HuggingFace
  • Cloud Integration: Connect to GPT models via OpenAI, Claude models via Anthropic, Mistral, Groq, MiniMax, and others
  • Custom Assistants: Create specialized AI assistants for your tasks
  • OpenAI-Compatible API: Local server at localhost:1337 for other applications
  • Model Context Protocol: MCP integration for agentic capabilities
  • Privacy First: Everything runs locally when you want it to

Build from Source

For those who enjoy the scenic route:

Prerequisites

  • Node.js ≥ 20.0.0
  • Yarn ≥ 4.5.3
  • Make ≥ 3.81
  • Rust (for Tauri)
  • (macOS Apple Silicon only) MetalToolchain xcodebuild -downloadComponent MetalToolchain

Run with Make

git clone https://github.com/janhq/jan
cd jan
make dev

This handles everything: installs dependencies, builds core components, and launches the app.

Available make targets:

  • make dev - Full development setup and launch
  • make build - Production build
  • make test - Run tests and linting
  • make clean - Delete everything and start fresh

Manual Commands

yarn install
yarn build
yarn dev

Building on Windows

Run make dev from Git Bash (installed with Git for Windows) — make dispatches its recipes through sh, so a plain cmd.exe won't work.

You do not need a "Native Tools Command Prompt for VS 2022". The bundled llama.cpp engine builds with Ninja + clang-cl, and clang-cl locates the MSVC toolchain and Windows SDK on its own. What has to be installed (and on PATH for ninja/clang-cl/cmake):

  • Visual Studio 2022 Build Tools (MSVC x64 workload + Windows SDK)
  • LLVM (provides clang-cl)
  • Ninja
  • CMake
  • CUDA Toolkit — only for JAN_ENGINE_VARIANT=cuda12/cuda13 builds

Engine variants are picked with JAN_ENGINE_VARIANT (tokens: cpu, vulkan, metal, cuda12, cuda13, hip/rocm, joined by -), e.g.:

make dev JAN_ENGINE_VARIANT=cuda13

"nvcc fatal : Could not open output file ...fattn-...cu.obj.d" during tauri-plugin-llamacpp(build) means the build path crossed Windows' 260-character MAX_PATH limit — nvcc does not honor the long-path opt-in. The build script now detects this and automatically relocates the llama.cpp build tree to a short directory under %LOCALAPPDATA%\jan-engine. If you hit path-length errors anyway, set JAN_ENGINE_BUILD_DIR to a short path (e.g. C:\jb) or move the checkout closer to the drive root.

System Requirements

Minimum specs for a decent experience:

  • macOS: 13.6+ (8GB RAM for 3B models, 16GB for 7B, 32GB for 13B)
  • Windows: 10+ with GPU support for NVIDIA/AMD/Intel Arc
  • Linux: Most distributions work, GPU acceleration available

For detailed compatibility, check our installation guides.

Troubleshooting

If things go sideways:

  1. Check our troubleshooting docs
  2. Copy your error logs and system specs
  3. Ask for help in our Discord #🆘|jan-help channel

Contributing

Contributions welcome. See CONTRIBUTING.md for the full spiel.

Note: Please sign your commits so we can verify your contributions.

Links

Contact

License

Apache 2.0 - Because sharing is caring.

Acknowledgements

Built on the shoulders of giants:

Frequently asked questions

Is Jan free to use?

Jan is open source. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Jan do?

Run AI models locally or connect to cloud, privately

What is Jan written in?

Jan is primarily written in TypeScript. Its source is publicly available at https://github.com/janhq/jan, and it has 44,512 GitHub stars.