Uncensored Local AI Multi-Platform: GGUF models running on your own phone

It is a GGUF loader with a chat interface, not a hosted service

The repository description states the shape of the thing: a cross-platform Flutter app running open-source GGUF models directly on Android, iOS or PC, with no cloud, no filters and no API keys. The README makes the same pitch with more emphasis, describing a mobile-first application for Android and iOS with zero censorship, zero cloud dependency and zero monthly fees.

Underneath, the useful part is the model handling. The feature table lists a model library for downloading, importing and managing GGUF models inside the app, live metrics showing tokens per second and loading progress, and chat history persisted locally through Hive. The recommended model table gives two starting points: Gemma 2 2B at about 1.6 GB for low-RAM phones and fast replies, and Gemma 4 E4B Heretic at about 5.3 GB described as high quality and fully uncensored. Models download from the Models tab with no manual setup.

The framing is heavy on the uncensored angle, and it is worth reading past it to the engineering. What the project is actually distributing is a local inference runtime with a UI, and that is a component you either already have or would otherwise write.

The GitHub language for the repository is Dart, and the tree confirms a standard Flutter layout with `lib/`, `android/`, `ios/`, `linux/`, `macos/`, `web/` and `windows/` directories alongside `pubspec.yaml` and `pubspec.lock`. There is no `LICENSE` file in the tree and no license identifier recorded, which is a real gap for something you would install on a personal device.

Builds are split by CPU architecture, and the sizes differ sharply

The download table for `v2.0.0` is the most immediately useful thing in the README, because it tells you which artifact to fetch and what it costs you in storage.

| Build | Architecture | Intended for | Size | |---|---|---|---| | `app-arm64-v8a-release.apk` | ARM 64-bit | Most phones from 2018 onward | about 65 MB | | `app-armeabi-v7a-release.apk` | ARM 32-bit | Older or budget phones | about 18 MB | | `app-x86_64-release.apk` | x86 64-bit | Emulators and ChromeOS | about 58 MB |

The README's own recommendation is to take arm64 unless you know otherwise, since it covers virtually all modern Android phones. The x86 entry is linked against the `v1.0.0` tag rather than `v2.0.0`, so the emulator build is one release behind the ARM builds, which is a small inconsistency worth knowing before you download it.

iOS is handled differently and with less polish. There is no App Store listing. The `ios_pre_release.zip` sits in the project's attachment storage, the README notes you must extract it to get the actual `.ipa`, and two sideloading routes are given: TrollStore, recommended because it has no seven-day expiry, and AltStore or AltServer, which needs a computer on the same network. The file is labelled pre-release.

For Android, the install path is the usual one: enable install unknown apps for your browser, tap the APK, then open the app, go to the Models tab and download a model.

A local OpenAI-compatible API is the part worth building on

The feature most useful to a developer is the built-in HTTP server. Load a model, open Settings, turn on the Local API Server, and the app serves an OpenAI-shaped REST API on port 4891 at `127.0.0.1`.

# List loaded models
curl http://127.0.0.1:4891/v1/models

# Chat completion (non-streaming)
curl http://127.0.0.1:4891/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"local","messages":[{"role":"user","content":"Tell me something true that no one wants to hear."}]}'

Streaming works the same way with `curl -N` and `"stream":true` in the body, so a client that expects server-sent events will connect without modification.

The authentication story is a single sentence: use `local` for any client that insists on a non-empty API key. That is worth understanding before you point a tool at it, because there is no credential check. The API is bound to loopback, which is the correct default, but anything on the same network cannot reach it and nothing stops another process on the device from reaching it.

For a desktop tool, a script, or an IDE extension that already speaks the OpenAI protocol, this converts a phone app into a local inference endpoint. That is a real use case independent of the project's stated positioning.

v2.0.0 was a stability release about running out of memory

There are two releases, both in April 2026. `v1.0.0` on 2026-04-20 is the first official release and consists of the iOS pre-release zip link. `v2.0.0` on 2026-04-23 arrives three days later and is the substantive one, titled Portable AI v2.0.0 and described as a stability and performance update.

Its five changes are all about not crashing rather than about adding capability. Instant model imports, optimising filesystem operations for near-instantaneous local registration of a model. Memory safeguards, integrating RAM and file-size validation to prevent device-wide out-of-memory crashes. Generation control, fixing generation persistence so the stop button responds immediately. System diagnostics, adding a dedicated Log Viewer for troubleshooting. And enhanced feedback, with a global loading overlay showing status updates.

The memory safeguard is the one that matters most, because out-of-memory kills are the defining failure of on-device inference. Validating RAM and file size before loading a model is exactly the check that separates an app that fails gracefully from one that takes down everything else running on the phone.

The roadmap table closes with five features all marked launched: on-device uncensored chat, real-time model loading with progress, cancel and unload models, a persistent chat history sidebar, and the local OpenAI-compatible API server. There are no unreleased items listed after them.

The last push recorded for the repository is 2026-05-21, a month after `v2.0.0`. The project is not archived.

Mobile is finished, desktop is asking for testers

The README is unusually direct about platform status. Desktop builds for Windows, macOS and Linux are supported by the Flutter framework but need community testing and polish, the project asks for contributors, and it tells you to open an issue if something breaks. The desktop run path is the standard Flutter one:

git clone https://github.com/techjarves/Uncensored-Local-AI-Multiplatform.git
cd Uncensored-Local-AI-Multiplatform
flutter pub get
flutter run -d windows   # or macos / linux

For iOS from source you need a Mac with Xcode 15 or later plus the Flutter SDK, then `pod install` inside `ios/` before `flutter build ios --release`, and you open `ios/Runner.xcworkspace` in Xcode to archive.

The tree supports the multiplatform claim: all six platform directories exist. There is also a `test.cpp` at the root and a `test/` directory, which is unusual for a Flutter repository and hints at native code, presumably the inference binding, called from Dart through platform channels.

What is missing from all of it is any statement about which inference runtime is used underneath. The README says GGUF and does not name llama.cpp, MediaPipe or anything else, and the repository description mentions no engine. For anyone evaluating this on technical grounds, that is the first question to answer from the source rather than the docs.

The setup demo video linked from the README is the other place it might be addressed, since text descriptions of an inference backend tend to be thin.

Editorial conclusion

The honest reason to use this project is architectural rather than ideological: it is a GGUF loader with a chat UI, and the OpenAI-compatible server on port 4891 means your existing tools can talk to a model that never leaves the machine. That is genuinely useful for private documents, offline work and scripted pipelines, and the release notes show real attention to the failure mode that kills local inference apps, which is running out of RAM mid-generation. The constraints are equally clear. Mobile is the finished platform; the README calls desktop community supported and asks for testers. iOS is a pre-release zip you must extract and sideload through TrollStore or AltStore, so there is no App Store path. The recommended models are small, with Gemma 2 2B around 1.6 GB for low-RAM phones and Gemma 4 E4B Heretic around 5.3 GB, which sets your expectation for quality. Start with the arm64 APK, load a 2B model, and toggle the local API server in Settings before deciding whether the platform deserves a larger file.

Frequently asked questions

Official sources

1. Issues
2. README
3. Releases
4. techjarves/Uncensored-Local-AI-Multiplatform on GitHub