Jan

Jan is a desktop app for downloaded local models, project-based conversations, and optional connections to other model providers. Choose it when you want to keep related chats and files together while controlling which model handles each task. A shared browser service with centrally managed users calls for a different deployment, such as Open WebUI or AnythingLLM's server edition.

Begin with one downloaded model and the internet tools turned off. Once ordinary chat works, add a harmless file and then any connection another application needs. Review the provider and tool destinations in the network section below.

Check the platform before installing

You can try local models on a compatible Windows or Linux computer using its CPU (the main processor) without sending model calculations to a GPU. Jan's current engine guide explicitly describes this mode. The version-specific guidance below covers stable Jan v0.8.6; its online guides also describe the bundled engine introduced in v0.8.5.

System RAM holds the CPU workload; VRAM is graphics memory. Neither the app's RAM minimum nor a model's download size establishes that a particular model and conversation will fit. Leave room for Jan, the operating system and your other applications.

Choose CPU operation or graphics acceleration

The engine guide tells Windows and Linux users how to turn off GPU offload, which transfers model calculations to the graphics processor. The troubleshooting guide also recommends this to isolate graphics failures. CPU operation is therefore a documented option, not merely an unverified workaround.

The Windows and Linux installation pages still list a 6 GB VRAM minimum without explaining its scope alongside documented CPU operation. They do not establish that 6 GB is a universal threshold for GPU acceleration or specify a supported lower threshold. For CPU use, follow the documented GPU-offload controls and check processor compatibility and enough system RAM for the model and context. Try the CPU workflow below on compatible existing hardware before buying a graphics card solely because of that table. For GPU acceleration, check the exact card, driver, supported backend and model memory needs; the unexplained 6 GB figure alone cannot confirm that a particular setup will work.

For a CPU trial on Windows or Linux, open Settings → Hardware → GPUs and turn off the GPU switches. Start a small compatible downloaded model with short context, then use the checkable prompt below. If a model was already running, stop it and load it again for the comparison. Watch system RAM and response time. If loading fails, inspect the reported error before changing hardware: insufficient memory, an unsupported model, and a processor-compatibility failure need different remedies. Disabling a GPU does not remove AVX2 requirements on the documented x64 path; current Jan has no downloadable backend selector for older processors without those instructions.

If you want GPU acceleration, choose the path for your hardware:

• NVIDIA on Windows or Linux uses bundled CUDA 13 where supported. Otherwise, Jan documents Vulkan, which requires a compatible graphics driver. Install a current driver supported by the card; the packaged app does not require the CUDA Toolkit.

• AMD and Intel graphics use the bundled Vulkan backend. Enable the detected GPU under Settings → Hardware → GPUs. On Linux, install the distribution's Vulkan loader as well as a compatible driver; the v0.8.6 AppImage uses the system loader.

• Apple Silicon uses Metal acceleration. Its shared memory arrangement is different from a PC's separate VRAM, so do not apply the Windows/Linux 6 GB figure to the Mac table. Turning off PC GPU offload does not make the bundled engine support Intel Macs.

The v0.8.6 release fixes a specific CUDA failure on NVIDIA Turing cards, including GTX 16-series and RTX 20-series models. If v0.8.5 reports an unsupported PTX toolchain on one of those cards, update Jan first: the release notes say that fix itself does not require a driver update. This is separate from maintaining a suitable driver for ordinary CUDA or Vulkan operation.

Use Jan's official download and the platform instructions linked in Sources. On Linux with Flathub already configured, the documented commands are:

flatpak install flathub ai.jan.Jan
flatpak run ai.jan.Jan

AppImage and .deb packages are alternatives with different installation and update procedures. Do not apply one package's storage or update instructions to another.

Establish a local conversation

1. Install and open Jan. Choose your analytics preference during onboarding.

2. Let the initial model download finish. In the chat selector, confirm the model belongs to a local engine rather than a cloud provider.

3. To choose another model, open Hub, inspect its details and hardware-fit indication, download it and select it in Chat. Treat the fit indication as planning guidance, not a quality test.

4. Turn off the globe or Web Search control. Jan's current documentation describes web search as enabled by default, using a keyless Exa endpoint. Leave other tools off too.

5. Send the fictional exercise below.

Rewrite this in plain English. Preserve every fact, number and
qualification. Do not add a reason:

The fictional Oak Club meeting will commence at 10:30 on Tuesday.
Attendance is optional. Bring two printed copies if you attend.

Check that the answer retains 10:30, Tuesday, optional attendance and the conditional two-copy instruction. Reject a mandatory-attendance statement or an invented purpose. These are checks on the invented input, not recorded Jan results. Restart Jan and repeat in a new chat to confirm that the same model can be reopened before adding more components.

Use the engine that supports the task

GGUF models use Jan's llama.cpp engine. From v0.8.5, that engine is bundled with the app; older instructions for downloading a different built-in backend are obsolete. Find its version under Settings → Model Providers → Llama.cpp, and inspect GPU choices under Settings → Hardware → GPUs. Updating Jan updates its bundled engine. Running a separate llama-server as a custom provider is a different, more involved option.

On Apple Silicon, Jan also documents experimental MLX support using MLX-Swift model format. Its current limitations include unavailable embeddings, reasoning output not surfaced separately, and some newer architectures failing to load. Use a compatible GGUF model when those limits affect document search or your chosen model. Renaming a download does not convert it between GGUF and MLX.

Start with short context. Context includes instructions, conversation history, supplied files, and space for the answer; a larger setting consumes more memory. If dedicated GPU memory is exhausted, reducing GPU Layers can move more work to system RAM, at a possible speed cost. It does not create memory. Close competing loaded models and change one setting at a time.

For a strict one-model setup, the llama.cpp router's Max Concurrent Models can be set to 1; its value 0 means unlimited. Avoid adding concurrency while investigating memory pressure. A model that fits on its own may struggle alongside an embedder and other applications.

Organize files and conversations in a project

A project groups conversations, an assigned assistant and shared files. Assistant instructions apply across the project's chats; project files can provide reusable context. A message attachment belongs to that message's conversation instead. Decide which scope you need before adding material.

Create a project using New Projects in the sidebar. Give it a concrete name, such as Oak orders, and use its Files panel to add a short text file. For this exercise, save the following fictional content as order-example.txt:

Order A17 contains three blue folders.
Delivery is Friday.
No price is stated.

Ask for the order identifier, quantity, color, delivery day and price, with quotations supporting each answer. Then ask for the carrier's name. The file supports A17, three, blue and Friday; it supplies neither a price nor a carrier. An invented carrier remains wrong even if the filename appears beside the response.

Open a second conversation in the project and repeat a question. Check that the shared file is available, then inspect the source behind the answer. File size and chunk count are diagnostic clues, not proof that every sentence was used. For longer documents, inspect extraction and retrieved passages before relying on a summary.

Jan's file documentation includes PDFs, Office files, and text formats. Image and audio input depend on the selected model's capabilities. A successful text conversation does not establish image understanding. A scan may need OCR, and a table can be extracted in the wrong order even when the document opens correctly.

Cowork and unfinished agent work were placed in the nightly channel in the v0.8.5 announcement. A link in rolling documentation does not make a preview a stable-release feature. Check your installed channel before building a workflow around it; the ordinary chat and file exercise does not require Cowork.

Review the routes out of the computer

Jan describes product analytics as permission-based, using a random identifier and PostHog EU, without collecting chats or prompts for those analytics. That is the vendor's stated analytics policy, not a description of every connected provider.

Web search sends queries to its provider. Web fetch requests a web page. A cloud model receives the prompt and included file content. A custom endpoint could be a process on this computer, a machine on your network or a hosted service. Read its address and ownership; a localhost interface can still forward requests elsewhere.

MCP, the Model Context Protocol, connects Jan to tools and data sources. Review where each server runs, what folders and accounts it can access, and whether it sends network requests. A local tool can still read sensitive files or contact an external service. Grant only needed access, inspect proposed action arguments, and do not treat instructions embedded in a document as permission to execute commands or send files.

For offline work, download the local answer model and required processing components first. Disable search, remote providers, and tools; quit Jan; disconnect networking; then reopen it. Test both a new chat and a new harmless file. A successful disconnected trial establishes that workflow's availability, not the behavior of every later online session or sync service.

Connect another application through the local API

Jan's local API server needs a loadable local model to start, even though it can subsequently route requests to configured remote providers. Download a suitable local model, then open Settings → Local API Server and choose it under Default Model Local API Server. Start the server and wait for its running status.

For personal use, retain host 127.0.0.1, port 1337, and prefix /v1. Configure a private API key and copy the exact local model ID. Leave Execute Tools on Server off for the first request. On macOS or Linux:

curl --fail-with-body http://127.0.0.1:1337/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"model":"YOUR_MODEL_ID","messages":[{"role":"user","content":"Rewrite without changing the time: The meeting will commence at 10:30."}]}'

Replace both placeholders. If you deliberately configured no key, omit the Authorization header. On Windows PowerShell, use this equivalent request:

$body = @{
  model = 'YOUR_MODEL_ID'
  messages = @(@{
    role = 'user'
    content = 'Rewrite without changing the time: The meeting will commence at 10:30.'
  })
} | ConvertTo-Json -Depth 5
$headers = @{ Authorization = 'Bearer YOUR_API_KEY' }
Invoke-RestMethod `
  -Uri 'http://127.0.0.1:1337/v1/chat/completions' `
  -Method Post -ContentType 'application/json' `
  -Headers $headers -Body $body

Inspect the returned assistant message. A successful connection isn't enough if the answer changes the time. A 401 response calls for checking the key; a 404 calls for checking the model ID, endpoint, and API prefix. Connection refused calls for checking server status, host and port. Jan does not automatically select another port when 1337 is occupied.

Binding to 0.0.0.0 allows network access and requires deliberate authentication, host and traffic-protection decisions. Keep the interface at 127.0.0.1 unless another computer must connect, and then use a strong API key and a firewall rule that lists the computers allowed to connect. Replace the key if you suspect it has leaked. A request made to Jan locally but routed to a remote model still sends content away. Review verbose API logs too: they can record incoming requests and responses.

Keep and remove data deliberately

Find the active location under Settings → General → Jan Data Folder. Defaults include %APPDATA%\Jan\data on Windows and ~/Library/Application Support/Jan/data on macOS. Native Linux and Flatpak locations differ. Use the path shown by the installed app rather than an old screenshot.

Quit Jan before making a folder backup. Models, threads, files, settings-related data, and logs may all matter; JSON or JSONL chat files are not automatically a polished Word export. Check what a recovery restores before depending on it. Credentials stored in the operating-system keyring may need separate reconfiguration.

Jan's relocation dialog describes copying data and leaving the original location intact. Inspect both locations before assuming a move erased the first copy. Factory reset is destructive and removes user data, including models and chat history. Uninstalling the app, removing a chat, unloading a model and deleting all data are different actions.

Imported models can be linked in place. Removing their Jan entry leaves the original file, which another application may also use. Conversely, deleting a Jan-managed download can reclaim its storage. Neither operation deletes independently stored attachments, backups, or remote-provider records.

The v0.8.4 migration moved secrets to the OS keyring but retained an older localStorage snapshot for downgrades. Removing a current credential does not establish that every historical copy disappeared. Review old copies if that is material to your cleanup. For cleanup, identify and remove the copies you control, subject to your retention requirements:

• Check the active data folder and backup or legacy folders for leftover files and snapshots.
• Review exports, manual backups and synced copies outside Jan's managed directories.
• Check older installations and user profiles for retained localStorage snapshots.
• After removing a credential from the OS keyring, review other credential stores and synchronized copies.
• Inspect app.log for confidential request data and remove retained logs where appropriate.
• When retiring a device or account, review trash and recycle bins too.

These checks do not prove that every historical copy has disappeared. For device sanitization, use a method appropriate to the storage medium and verify its outcome. Ordinary file overwriting or shredding cannot reliably reach all old data on wear-levelled SSDs or flash storage; follow the device manufacturer's supported sanitization procedure and your organization's policy.

Update before using destructive recovery steps

For model-loading problems, check the release notes for a matching fix before resetting data. Version 0.8.6 addresses Linux AppImage loading failures as well as the Turing issue described above. Update through your installation channel: for Flatpak, use flatpak update ai.jan.Jan; .deb users follow the newer package's installation process, while AppImage has its own updater.

For other loading failures, check format, available memory, context and the engine startup details in logs/app.log under the active data folder. Try a smaller compatible model. Remove sensitive information before sharing logs. For a custom provider that lists no models, verify its expected API format and base path, and enter its exact model ID manually where discovery is unavailable.

Compare Jan with alternatives using the same source text and questions. Project organization may be valuable even when another app offers the same broad categories of local models, documents and APIs. Jan's Apache 2.0 software terms remain separate from model licenses and remote-service conditions.

Related pages

• Local AI software
• Local AI privacy
• Compare LM Studio and Jan

Sources

• Quickstart, Mac installation, Windows installation and Linux installation.

• Model management, llama.cpp engine, experimental MLX, Projects and file uploads.

• Web Search, privacy, MCP, API server and custom endpoints.

• Data folder, settings, v0.8.4 migration, v0.8.5 changes and v0.8.6 fixes.

• Stable v0.8.6 release notes and hardware and model troubleshooting.

• NIST guidance on media sanitization and verification.

• Jan desktop setup

• Jan source and releases