Local NSFW AI chatbots: run uncensored roleplay on your own PC

A local NSFW AI chatbot is a language model that runs on your own machine rather than on a company's servers. That means no account, no platform filter and no monthly fee, and every chat stays on your own drive. It is a good fit for adults who own a capable gaming PC or a recent Mac and are happy to spend a little time on setup.

As a floor, you want 8 GB of VRAM on your graphics card (12 GB and up is nicer), or 16 GB or more of unified memory on an Apple Silicon Mac. Our beginner pick: KoboldCpp plus SillyTavern running a 12B-class roleplay model in Q4_K_M, or a 7 to 9B model if your card has 8 GB.

Why run an NSFW chatbot locally

• Privacy. SillyTavern sends your messages to a program on the same machine, and they travel no further unless you hook up a cloud service yourself.
• No platform filter. Hosted services write their own content rules and revise them whenever they like. On your own PC, the only boundaries are whatever the chosen model learned in training.
• No subscription or message caps. Both the software and the models cost nothing; your outlay is the hardware and the power bill.
• Offline use after the downloads are done.

What you give up:

• Hardware cost. A smooth experience calls for 12 GB of VRAM or more, or a 32 GB Mac for mid-size models, and that purchase can outweigh many months of a hosted plan.
• Setup time. You install two programs, fetch a download of several gigabytes and adjust a few settings that really matter, then keep it all updated.
• Smaller models write worse. Anything that fits on a gaming GPU is far smaller than the biggest hosted models, so expect more repeated phrases, a shakier memory and more nudging on your part.
• No images or voice out of the box. KoboldCpp is able to load image and speech models, and SillyTavern has extensions for both, yet each one means extra downloads and extra memory.

Hardware: how much memory you need

The whole model must sit in fast memory, which means your graphics card's VRAM or the unified memory of an Apple Silicon Mac. The figures below are rough estimates rather than measurements, assuming Q4_K_M (the usual 4-bit quantization, covered further down) and a context size with some headroom; your results will vary by model and backend.

A simple rule of thumb: take the GGUF file size, add 2 to 5 GB for context and working space, and the total should fit inside your VRAM. Some reference points: the RTX 3090 and 4090 carry 24 GB; the RTX 4060 Ti 16 GB, 4080 and 5080 carry 16 GB; and the RTX 3060 12 GB, 4070 and 5070 carry 12 GB. Laptop GPUs frequently carry less VRAM than the desktop card with the same name, and Task Manager lists yours under Performance, GPU.

NVIDIA hardware is the least trouble because every tool here supports CUDA. AMD and Intel cards run through Vulkan (plus ROCm for AMD), which takes more setup and is often slower.

VRAM, system RAM and offloading

When a model is too big for VRAM, KoboldCpp, Ollama and LM Studio can park some of it in system RAM and let the CPU handle that portion. This works, but system RAM is much slower: moving a few layers there costs a bit of speed, while moving half the model can make replies several times slower. Plan on 32 GB of RAM if you intend to offload.

Mixture-of-experts (MoE) models handle this better. A label such as 35B-A3B means 35 billion parameters overall with roughly 3 billion active for each token. Memory needs track the total and speed tracks the active share, so these models remain usable even when part of them lives in system RAM.

Apple Silicon and unified memory

Because the CPU and GPU in an M-series Mac draw on one shared memory pool, a Mac with 32 or 64 GB can hold models that a PC could only load with a pricey graphics card. macOS reserves some of that memory for itself; count on roughly two-thirds to three-quarters being free for the model. Generation speed depends on memory bandwidth, which is higher on Pro, Max and Ultra chips, and long prompts are processed more slowly than on a comparable NVIDIA rig. Intel Macs are largely stuck with the CPU.

Software: a backend plus a frontend

The backend is the part that loads the model and produces text. The frontend is the chat window you actually type into: it keeps your characters, assembles every prompt and passes it to the backend. SillyTavern is the go-to roleplay frontend and connects to each backend listed here.

TextGen is the current name for text-generation-webui, which many people still call oobabooga after its creator. LM Studio costs nothing for home or work use but its code is closed; every other tool in the table is open source. Ollama's built-in library leans toward general-purpose models, though it can also fetch roleplay fine-tunes straight from Hugging Face.

Download each tool only from its official home. For KoboldCpp that is github.com/LostRuins/koboldcpp; SillyTavern lives on github.com/SillyTavern/SillyTavern; Ollama comes from ollama.com; LM Studio from lmstudio.ai; TextGen from github.com/oobabooga/textgen; llama.cpp from github.com/ggml-org/llama.cpp; and the models themselves from huggingface.co.

Models: GGUF files, quantization and fine-tunes

GGUF and quantization

All of the backends above read GGUF, the file format from llama.cpp, which packs the weights and metadata such as the chat template into a single file. Large models are sometimes split into numbered parts; point the backend at the first part.

Quantization saves each weight with fewer bits than the original 16, cutting memory use in exchange for some loss of quality:

• Q8_0: around 8.5 bits per weight, and in practice you cannot tell it from the original.
• Q6_K: around 6.6 bits, extremely close to the original.
• Q5_K_M: around 5.7 bits, a slight drop.
• Q4_K_M: around 4.8 bits, or about 0.6 GB per billion parameters. This is the standard choice, giving up a little quality for a big memory saving.
• Below Q4 (Q3_K_M, Q2_K and similar): visible degradation, and small models suffer the most.

In general a larger model at Q4_K_M beats a smaller sibling from the same family at Q8_0, so put your memory toward size first. Files whose names begin with IQ, for example IQ4_XS, use another method that is smaller for similar quality but can run slower.

Base families and community fine-tunes

Most roleplay models people run at home are community fine-tunes: open base models released by big labs and then trained further on fiction and roleplay text. Common base families seen in model names are Llama (Meta), Mistral and Mistral Nemo (Mistral AI), Qwen (Alibaba) and Gemma (Google), and plenty of popular models blend several fine-tunes together. "Uncensored" is a loose promise that the model will not refuse; "abliterated" means refusals were stripped out by editing the weights directly.

We deliberately avoid crowning a single best model, because fine-tunes rise and fade within weeks. Instead, search Hugging Face for a family and size your hardware can handle plus GGUF, sort by trending or recently updated, and check what the SillyTavern and LocalLLaMA subreddits think of the latest releases.

How to read a model card

• Base model, listed on the card or in the Model tree panel on Hugging Face. It mostly determines which instruct template you need.
• Size. The parameter count tells you which row of the hardware table to use; for MoE models, go by the total.
• Context length. Plenty of fine-tunes get worse long before the base model's stated limit, and a well-written card tells you where that happens.
• License. Read it along with the base model's license. Recent open releases from Qwen, Mistral and Gemma are Apache 2.0, while Llama ships under Meta's community license with an acceptable use policy.
• Intended use and recommended settings, such as the instruct template and sampler values the creator tested with.
• GGUF links. Quantized versions normally live in their own repository with GGUF in the name, reachable from the Model tree.

How to judge a model yourself

1. Keep the character card, first message and settings identical for every model, swapping only the instruct template.
2. Produce three to five replies to one message (swipes, in SillyTavern) and line them up.
3. Look at whether the character holds its voice and facts, avoids writing your part, changes up its phrasing and never drifts into assistant-style talk.
4. Carry on for 30 to 50 messages, then ask about a detail from the start of the conversation.
5. Stick with whichever model makes the fewest mistakes.

Step-by-step setups

The menu names below follow the current releases; if something has moved, the project's own documentation will have the new location.

Route 1: KoboldCpp and SillyTavern on Windows

1. Grab KoboldCpp from the GitHub releases page: koboldcpp.exe if you have an NVIDIA card, koboldcpp-nocuda.exe for AMD or Intel graphics.
2. Pick a roleplay fine-tune small enough for your VRAM and save its Q4_K_M GGUF file. You can also find models with the HF Search button in the launcher.
3. Start koboldcpp.exe. Windows might flag it as an unrecognized app, which happens a lot with unsigned open-source software.
4. On the Quick Launch tab, make sure Backend reads Use CUDA (NVIDIA) or Use Vulkan (AMD, Intel), then press Browse beside GGUF Text Model and select your file.
5. Keep GPU Layers at -1 (automatic) to begin with. When the file fits in VRAM with space left over, type in the full layer count displayed beside it so that every layer runs on the GPU.
6. Choose 8192 or 16384 for Context Size and press Launch. Once loading completes, KoboldCpp's built-in chat page appears at http://localhost:5001.
7. Install Node.js (LTS) and Git. Inside a folder you control (not Program Files), open a terminal and run git clone https://github.com/SillyTavern/SillyTavern -b release, then double-click Start.bat in the folder it creates. SillyTavern then loads at http://127.0.0.1:8000.
8. Go to API Connections (the plug icon), choose Text Completion as the API and KoboldCpp as the API Type, type http://localhost:5001 into the API URL field, tick Derive context size from backend and press Connect.
9. Go to AI Response Formatting (the A icon), switch on Instruct Mode and enable the options that pull the context and instruct templates from the model. If the template is not detected, choose the one named on the model card.

Route 2: Ollama and SillyTavern on macOS or Linux

1. Install Ollama: on macOS use the app from ollama.com (version 14 or newer, Apple Silicon for GPU acceleration); on Linux run curl -fsSL https://ollama.com/install.sh | sh.
2. Fetch a roleplay fine-tune from Hugging Face using ollama pull hf.co/user/repository:Q4_K_M with the model's own path; the tag after the colon selects the quantization.
3. Leave Ollama running (as the app, the Linux service or via ollama serve); it waits for requests at http://127.0.0.1:11434.
4. Set up Git and Node.js (Mac users will find Homebrew the quickest way). After that, run git clone https://github.com/SillyTavern/SillyTavern -b release, cd SillyTavern and ./start.sh.
5. Under API Connections, pick Text Completion, set API Type to Ollama and the API URL to http://127.0.0.1:11434, press Connect and choose your model from Ollama Model.
6. Under AI Response Formatting, turn on Instruct Mode and choose the template given on the model card, because auto-detection does not work with Ollama.
7. Under AI Response Configuration (the sliders icon), set Context (tokens), and tick Unlocked if you want more than 8K. SillyTavern sends that value to Ollama on every request.

Route 3: LM Studio as a single app

1. Get LM Studio from lmstudio.ai. It supports Apple Silicon Macs (macOS 14 or newer), Windows PCs (x64 with AVX2, or ARM) and Linux.
2. On the Discover tab, look up a roleplay fine-tune and download a Q4_K_M file; LM Studio flags the files that should fit your machine.
3. On the Chat tab, open the model loader, choose the model and adjust context length and GPU offload.
4. Write the character and scenario into the system prompt and store it as a preset. On a Mac you can also use MLX models, an Apple-only format that may run faster.
5. To use character cards, launch the server from the Developer tab, link SillyTavern via Text Completion with API Type Generic (OpenAI-compatible) and the URL http://127.0.0.1:1234, and pick the instruct template the same way as in Route 2.

Settings that matter for roleplay

Context length

Context is the model's short-term memory, measured in tokens. One token is about three-quarters of an English word, so 8K tokens cover roughly 6,000 words. The system prompt, the character card, any lorebook entries and the latest messages all compete for that space, and once it is full SillyTavern removes the oldest messages. Larger context eats memory and time, which makes 8K to 16K the realistic range; set the same number in both the backend and SillyTavern.

Temperature, min-p and top-p

Temperature controls randomness: raise it for more varied writing and more errors, lower it for safer but flatter output. Min-p discards words that are improbable compared with the top candidate (at 0.05, anything less than 5 percent as likely), which keeps output sensible even at higher temperatures. Top-p and top-k are older and cruder filters; when using min-p, turn them off by setting top-p to 1 and top-k to 0.

Repetition penalty

The repetition penalty lowers the odds of words that appeared recently. Keep it gentle, about 1.05 to 1.1 across the last 1,000 to 2,000 tokens (Rep. Pen. Range in SillyTavern); push it higher and the model starts dodging names and everyday words. With KoboldCpp, llama.cpp and TextGen, SillyTavern also provides DRY, which goes after repeated phrases instead: put its multiplier at about 0.8, leave the rest at default and set the normal penalty to 1.0.

Instruct templates

Models tuned for instructions expect the conversation to be wrapped in particular markers, for example ChatML or the Llama 3, Mistral and Gemma formats. SillyTavern builds the prompt using whichever template you choose, and a wrong choice is easy to spot: the model speaks for you, leaves stray tags, keeps going without stopping or drops the character's voice. The correct template is listed on the model card. Some recent models produce a reasoning section before each answer, which uses up time and tokens; turn that off if the model lets you.

A sensible starting preset

Open AI Response Configuration and click Neutralize Samplers first. Then enter these values: Temperature somewhere from 0.8 to 1.0; Min P from 0.05 to 0.1; Top P at 1; Top K at 0; Repetition Penalty at 1.05 over 2,048 tokens, or alternatively DRY at 0.8 with that penalty set to 1.0. Response (tokens) can go between 250 and 400. When replies stop making sense, drop the temperature by 0.1; when they feel lifeless, nudge it up. Adjust a single setting at a time, and begin with the model card's numbers if it lists any.

Characters: cards and lorebooks

A character card is a compact file describing a persona. The widely used Chara Card V2 format stores a name, description, personality, scenario, first message, sample dialogue, alternate greetings, tags and, optionally, a built-in lorebook. Cards are shared either as JSON or as PNG images carrying the JSON inside, so the picture and the definition stay together. SillyTavern also reads the newer V3 format, which builds on V2. To learn how to read one, see our guide to character cards.

To add one in SillyTavern, click the card icon for Character Management. A PNG or JSON goes in through Import Character from File; a link from a supported site such as Chub goes in through Import content from external URL. Look at the token count before you start: cards above roughly 2,000 tokens take up too much of a small context. Chub AI hosts one of the biggest public collections of cards and lorebooks, and what you download there works in SillyTavern.

Lorebooks, which SillyTavern calls World Info, store background details like locations, supporting characters and rules. An entry is only added to the prompt when one of its keywords shows up in recent messages, so even a large world uses context mostly when it is relevant.

Running things at home does not suspend content rules. Our directory leaves out cards that hint at minors (including characters who appear young or are placed in school settings), real people and non-consent, as described in our content policy. Use the same standard for anything you download, because a local model will write whatever a card requests and the responsibility rests with you.

Easier options

If juggling two programs sounds like too much, HammerAI offers a desktop app for Windows, macOS and Linux that runs open models on your machine via a bundled copy of Ollama. It comes with a character chat interface and needs no account for local chat, swapping some control for almost zero setup.

If your hardware is not up to it, a hosted platform is the sensible route: several offer generous free tiers and frequently run bigger models than a home PC can, though you give up privacy and accept daily caps. Check today's free limits in our free NSFW AI chat ranking, or browse every service on the platform list.

Privacy and safety

• Your chats are files. Every chat and character is saved in SillyTavern's data folder, open to whoever is logged into your user account. Protect it with a password, disk encryption (BitLocker or Device Encryption on Windows, FileVault on a Mac) and a separate user account on shared machines.
• Keep the servers local. Out of the box, SillyTavern accepts connections only from your own machine. If you make it reachable on your home network, leave its whitelist enabled and never put it on the open internet. Keep KoboldCpp's Remote Tunnel switched off and leave Ollama's bind address alone unless you have a clear reason, since anyone who can reach these servers can use them.
• Know where messages go. Once SillyTavern is linked to a cloud API, your conversations are sent to that provider.
• Download from official sources. Take models from established authors on Hugging Face and favour GGUF or safetensors files, because older pickle formats (.bin, .pt, .pth) are able to execute code when loaded. Do not run an installer pretending to be a model, and keep your backend up to date, as security flaws in model file parsing have turned up in the past.
• Adults and fiction only. Do not create or share sexual content about real people, and keep minors out of it entirely.

Hosted services bring their own privacy concerns, which our privacy checklist walks through.

Frequently asked questions

Can I run an NSFW AI chatbot on my own PC?

Yes. A graphics card with 8 GB of VRAM or more, or an Apple Silicon Mac with at least 16 GB of memory, is enough to run an open model using free tools like KoboldCpp and SillyTavern. You face no platform filter, need no account, and your chats never leave your machine.

How much VRAM do I need?

At the standard 4-bit quantization with an 8K to 16K token context, a 70B model wants about 48 GB, a 22 to 32B model about 24 GB, a 12 to 14B model about 12 GB, and a 7 to 9B model about 8 GB. Short on VRAM? Part of the model can spill into system RAM, which still works, just with far slower replies.

Is local AI roleplay free?

Yes for the software and the model downloads, and you face no subscriptions or message caps. The real costs are the hardware, the electricity and the time you put in.

What is the easiest way to start?

The lowest-effort option is HammerAI's desktop app, which runs local models behind a character interface. If you want more control, pair KoboldCpp with SillyTavern on Windows or Ollama with SillyTavern on a Mac, and begin with a 12B-class roleplay model if you have the memory for it.

Can a Mac run local AI roleplay?

Yes, as long as it has an Apple Silicon chip (M1 or newer). With 16 GB of memory a Mac copes with small models, 32 GB covers mid-size models, and 64 GB or more can run 70B models. Ollama, LM Studio, KoboldCpp and SillyTavern all support Apple Silicon, while Intel Macs fall back mostly on the CPU, which is slow.

Is it legal?

In most countries it is legal to run open models on your own computer, but whatever you generate still falls under local law, and some model licenses limit certain uses. Many countries treat sexual content involving minors as illegal even when it is fictional or AI-generated, and a growing number make sexual depictions of real people without consent illegal or open to legal action. Treat this as general information rather than legal advice.

Full comparison: AI sex chat: best uncensored sex chatbots.

Secrets AI Top partner, #1 of 28

Try free ↗︎