# OpenChar Studio: one portable .char across models, on a node canvas

> A GPL-3.0 character studio that keeps a character's identity in a single portable .char and runs generation and LoRA training on the same node canvas, locally or through hosted API nodes. The install is one script, and the trap is on Windows, where the default torch wheel is CPU-only and nothing fails loudly.

**OpenCharAI/OpenChar** — AI character studio for portable identity. Build multi model consistent characters, train LoRAs, and generate on your own GPU.

- Repository: https://github.com/OpenCharAI/OpenChar
- Website: https://inlinestudio.art/
- Stars: 510 · Forks: 72
- Language: Python
- License: GPL-3.0
- Published: 2026-09-18 · Updated: 2026-09-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/opencharai-openchar

## One .char file is the unit, and the canvas is the whole interface

What the project is trying to fix is character drift. You generate a face in one model, move to a different one for the next shot, and the person changes. Here the identity is a single portable `.char` file, and the claim is that it keeps working across every model rather than only inside one. Everything else follows from that: the same character renders through a local GPU model or through a hosted API node without a second definition.

The workspace is a node canvas, described in `package.json` as AI filmmaking on a node canvas, with generation and LoRA training on that same canvas rather than in a separate tool. Two details matter for how you work. Hosted models appear as API nodes, so a project can mix a local checkpoint and a remote one in the same graph. And every render is kept as a versioned take, which means a bad frame is a version you can go back to instead of a file you overwrote.

## The project answers to three names, and ships as two PyPI packages

Naming is the first practical obstacle. The repository is OpenCharAI/OpenChar, the README is titled Omnichar Studio, the install instructions clone `https://github.com/omnichar/OmniChar`, and `package.json` is named `inline-studio` with its repository field pointing at `inlineresearch/Inline-Studio`. The homepage is inlinestudio.art. So the clone URL, the GitHub path and the npm-style package name are three different strings for one codebase, and searching by any one of them turns up something else.

The runtime is two Python packages. `omnichar-core` is the engine that also serves the web UI, and `omnichar-frontend` is a prebuilt SPA wheel, which is why the UI needs no Node step even though the repository is full of TypeScript and a Vite build. The two version independently, and the launch banner prints both lines and then tells you which one is behind, as in `omnichar-core 1.3.16, omnichar-frontend 1.3.15` followed by an update hint. The check runs once a day in the background, and `INLINE_NO_UPDATE_CHECK=1` turns it off. Re-running the install is the update path for both halves at once, which is why a `git pull` followed by `--install` moves the engine and the UI forward together.

## The VRAM column is copied out of TRAINING.md, and part of it is interpolated

The model table in the README is honest about its own provenance in a comment above it. The VRAM column mirrors a benchmark section in `TRAINING.md`, that file is the source of truth, and the comment notes it is the only figure the README repeats from another document. The same paragraph says not every row has been run on a 16GB card, and that the benchmark results say which were measured and which are interpolated.

That distinction matters when you pick a card. FLUX.2 klein Base 4B and 9B is quoted at about 8.6GB, FLUX.1 dev in 4-bit at about 10.4GB, Krea 2 RAW in 4-bit at about 11.9GB, Z-Image Turbo at about 13.4GB, and MiniMax H3 for video and sound at about 12.7GB, marked as working on a 16GB card but slowly. LTX-2.5 is the row that says no, and wants 48GB. Hosted API nodes need no GPU at all. These are training peaks at 512px, and a LoRA trained at 512 applies at any generation resolution, so the number to plan against is the training peak and not the render size. The H3 row also carries a system RAM cost, since on a 16GB card it moves its text encoder to the CPU, which is why it is cheapest in VRAM and slowest in time, and it wants 64GB of system RAM to do it.

## Install is one script, and the virtualenv belongs to the application

You need Python 3.11 or newer. There is no Node step for the end user, because the UI arrives as a Python wheel. On macOS and Linux:

```bash
git clone https://github.com/omnichar/OmniChar
cd OmniChar/core
./webui.sh --install --extra all
./webui.sh                         # http://127.0.0.1:8848
```

On Windows use `webui.bat`, and the README says why in one line: `webui.sh` is a bash script and will not run in PowerShell.

Two behaviours are worth knowing before you run it. Everything lands in `core/.venv`, which the studio owns, so an environment already activated in your shell is never touched, and re-running `--install` is safe. On NVIDIA, `--install` reads your GPU's compute capability and pulls the matching CUDA build of PyTorch, RTX 50-series included, which is the whole reason the script exists instead of a requirements file. If the CUDA build picked is wrong for your card, the Windows form takes `--torch-index cu130` to name the index yourself. The pip route also exists: `pip install -r requirements.txt` from the repository root installs the whole app from PyPI, then you run `inline-studio`.

## On Windows the default torch wheel is CPU-only and the install still succeeds

The comment block at the top of `requirements.txt` is the most useful file in the repository. PyPI's default `torch` is a CPU-only build on Windows, while the Linux wheels bundle CUDA. Install without an extra index line on Windows and you get a working install that generates on the CPU, roughly 100x slower, with no error. Core does warn at startup if it finds an NVIDIA GPU behind a CPU-only torch, or behind a build with no kernels for the card, but the warning is not the same as a failure, and nothing tells you during installation.

The three index lines cover the card ranges. RTX 50-series and newer, sm_120, needs a CUDA 13 driver and the cu130 index; on a Blackwell card with an older driver, use cu128. Everything from GTX 10-series through RTX 40-series, sm_50 to sm_90, uses cu126. Running `webui.sh --install` sidesteps the choice entirely by reading the compute capability. One more size decision sits in the same file: `[all]` is the whole app in one line, engine plus local runtime plus trainer plus server, while a hosted-only setup with no local generation should use `omnichar-core[server]`, which skips the roughly 2.5GB torch download.

## Linux on NVIDIA is tested, Apple Silicon and ROCm are code paths that exist

The hardware table separates what has run from what has merely been written, and it is blunt about the difference. NVIDIA on Linux is the tested row: Z-Image Turbo at 1024 squared on a T4 with 16GB, and Krea 2 at 1024 squared plus LoRA training on an L40S with 48GB, with no extra steps. NVIDIA on Windows is listed as supported, with the note that the CPU-only torch default is why `--install` picks the CUDA build for you. Apple Silicon on MPS is a code path that exists and is untested, and the extra steps column says no int8 quantising on MPS, so a model has to fit unified memory, while a ComfyUI int8 load does work.

AMD is untested on both operating systems, and the Windows case has its own wall: pytorch.org has no ROCm wheels for Windows, so you need AMD's own. That single line also sets the project's relationship to its closest alternative. ComfyUI is the comparison point used inside the table, and the difference is narrow and specific rather than general: ComfyUI's int8 loads on MPS where this project's does not. Everything else about a node canvas for image and video generation is shared ground, so the case for one over the other rests on the portable `.char`, the local LoRA trainer, and which card you own.

## Configuration is INLINE_ prefixed, and the API key is deliberately kept out of your shell

The `.env.example` file says you usually do not need one, because the friendly `webui.sh` flags set the variables for you, and the file exists to document them. The set that affects behaviour: `INLINE_HOST` and `INLINE_PORT` for the bind address, with `0.0.0.0` allowing other machines on the network; `INLINE_MODELS_DIR` defaulting to `./models`, which is where weights are scanned from; `INLINE_DATA_DIR` defaulting to `./.inline` for runs and generated takes; and `INLINE_PROFILE`, which takes `gpu-max`, `lowvram` or `cpu` and otherwise auto-detects. Two are about pretending hardware you do not have: `INLINE_VRAM_BUDGET_GB` treats the GPU as having a given number of usable gigabytes, and `INLINE_PARALLEL` takes a multi-GPU split such as `pipefusion=2`, automatic with two or more GPUs.

One choice deserves attention. The fal.ai key for hosted models is not an environment variable at all. You add it in the application's Settings, where it is stored server side under Core's data directory, so it never sits in your shell environment or in a file you might commit. That is a better default than most projects manage, and it also means a headless deployment has to go through the Settings page rather than a variable in a unit file.

## Conclusion

Adopt OpenChar Studio if you need the same face across shots and across model families and you have a Linux box with an NVIDIA card, since that is the one configuration the project states it has run. Skip it if you are on Apple Silicon or ROCm and need the int8 path, because those rows are marked untested and MPS has no int8 quantising. Verify first which of the two PyPI packages your checkout is behind, because the engine and the prebuilt UI version separately and the launch banner prints both, then run `./webui.sh --install` rather than `pip install -r requirements.txt` on Windows, where the default torch build is CPU-only. Licence is GPL-3.0, v1.3.26 shipped int8 model support on 2026-09-25, and the last push was 2026-09-29.

## FAQ

### What is OpenChar Studio used for?

It is a node canvas for keeping one AI character consistent. A character's identity lives in a single portable .char file, and the same character can be generated through a local GPU model or a hosted API node, with LoRA training available on the same canvas.

### How do I install OpenChar Studio?

Clone the repository, change into the `core` directory, then run `./webui.sh --install --extra all` on macOS or Linux, or `.\webui.bat --install --extra all` on Windows, since the bash script will not run in PowerShell. Launch it with `./webui.sh` and the UI comes up on http://127.0.0.1:8848.

### What are the OpenChar Studio hardware requirements?

Python 3.11 or newer. On NVIDIA Linux, Z-Image Turbo at 1024 squared was run on a T4 with 16GB and Krea 2 plus LoRA training on an L40S with 48GB. Apple Silicon on MPS and AMD on ROCm are listed as untested, and MPS has no int8 quantising, so a model must fit unified memory.

### Which models can OpenChar Studio train LoRAs for?

FLUX.2 klein Base 4B and 9B, FLUX.1 dev in 4-bit, Krea 2 RAW in 4-bit, Z-Image Turbo, MiniMax H3, and LTX-2.5. Hosted API nodes are generate-only. Quoted training peaks at 512px range from about 8.6GB for FLUX.2 to 48GB wanted by LTX-2.5.

### Why is OpenChar Studio slow on my Windows GPU?

PyPI's default torch is a CPU-only build on Windows, so an install without an extra index line gives you a working install that generates on the CPU, roughly 100x slower, with no error. Run `webui.sh --install` or `webui.bat --install`, which reads the compute capability and pulls the matching CUDA build.

### How is OpenChar Studio licensed?

GPL-3.0, declared as GPL-3.0-or-later in `package.json`. The engine and the prebuilt UI ship as two separate PyPI packages, `omnichar-core` and `omnichar-frontend`, which version on their own schedule.

## Sources

- [License: GPL-3.0](https://github.com/OpenCharAI/OpenChar/blob/main/LICENSE)
- [OpenCharAI/OpenChar on GitHub](https://github.com/OpenCharAI/OpenChar)
- [Project website](https://inlinestudio.art/)
- [README](https://github.com/OpenCharAI/OpenChar/blob/main/README.md)
- [Releases](https://github.com/OpenCharAI/OpenChar/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/opencharai-openchar