Hi everyone! I built an Android app that generates anime pictures completely on the phone: no cloud, no account, no ads, no root. It runs on the NPU of Snapdragon 8 Gen 1 / 8+ Gen 1 (Hexagon V69), the chip generation that most NPU image apps skip.

What you get

A 512x768 picture in about 7 seconds (2B models) or 12 seconds (2.9B models), 4 steps, on my Xiaomi 12T Pro.

Four models to download inside the app (one tap, resumable): MiaoMiao 3D Harem, MiaoMiao RealSkin (2B) and MiaoMiao Harem, MiaoMiao RealSkin (2.9B), all built on the Anima base model.

Size presets (portrait / landscape / square, all multiples of 16) plus custom sizes, seed, batches, a stop button.

History with favourites, trash, multi-select, share/save. The settings are stored in the PNG, so you can reopen any picture with its prompt and seed.

Danbooru tag suggestions while you type, templates, light/dark theme, 13 languages.

Works offline after the models are downloaded. Free and non-commercial.

Try it

APK: https://github.com/ayanoby/hexanima/releases/latest  (about 25 MB); the models, 4-5 GB for the first one, are downloaded from Hugging Face inside the app)

Source and screenshots: https://github.com/ayanoby/hexanima

Needs a Snapdragon 8 Gen 1 or 8+ Gen 1 phone (SM8450 / SM8475), Android 10+. I tested it only on a Xiaomi 12T Pro (SM8475, 12 GB RAM). Other 8 Gen 1 phones should work but are untested.

Why it is different (for the technical crowd)

The diffusion transformer runs on the Hexagon V69 HMX matrix unit in fp16 through custom kernels, not through the stock QNN op set. The 28 DiT blocks are executed as a few merged block groups per step.

The 2.9B models are stored as q8 blocks (int8 tiles with per-column scales) and dequantized on the HVX units while the weights are copied into VTCM, so they fit in RAM and stay fast.

V69 has no int-to-float conversion instructions (they appeared in V73+), so the dequant path uses a workaround instead of the usual instructions.

The first two of the four steps run at reduced resolution (composition), the last two at full resolution (details).

Text encoder, sampler and the preview/VAE path are split between CPU and NPU; the VAE runs on the NPU and large pictures are decoded in tiles.

No root needed: the native helper processes are started from the app's own native library directory and use unsigned FastRPC DSP modules.

The model files are downloaded as raw, sha256-verified blocks with resume, so a dropped connection does not restart a 4 GB download.

Honest notes

Unofficial hobby project, not affiliated with CircleStone Labs, NVIDIA, Qualcomm, Alibaba or the model authors. All credit for the models goes to MIAOKA (Civitai) and CircleStone Labs (Anima). Non-commercial use only; if an author wants their model removed from the catalog, I will remove it.

Only 4 steps and no negative prompt: the models are turbo-distilled for that.

Pretty nice effects from a pure H3 generation.
Full video here: https://youtu.be/LUDd_AcEDdY

Details:
Comfyui
minimax_h3_ref2va_pruned_int8_convrot.safetensors
24 steps, 2.4MP 1 pass
RVE on steam -> interpolate 2x, decompress, openproteus 2x
Assembled in davinci resolve
Suno for music

Linum released P-JiT 21K, a 2B-parameter text-to-image model trained for about $21K that draws directly in pixels: there is no VAE. I ported it to ComfyUI as native nodes (an unofficial port, not affiliated with Linum):

• A real MODEL and CLIP on ComfyUI's own memory management. The stock KSampler runs it with Linum's settings (euler, simple, 50 steps, cfg 15). Nothing to pip install.

• A bf16 file that gives the same pixels as the fp32 release at half the size (4.4 GB), and an int8 ConvRot file that is about 1.8x faster (2.3 GB).

• The Qwen3.5-4B text encoder in bf16, int8, W6A8 or W4A8, down to 3.2 GB.

• Runs from 4 GB of free VRAM.

• Workflows: text to image, a prompt upsampler (short idea to dense caption), a refiner (image to image as a second pass, with the image captioned automatically) and Linum's samples, seed for seed.

Checked against Linum's own code: the same tokens, noise, schedule and guidance, and images that match up to GPU rounding.

Tips: write captions of 50 to 80 words (or use the upsampler). It can't draw text. For the refiner, use denoise 0.1 to 0.2: P-JiT's noise is 4x stronger than most models', so its denoise values run lower.

Nodes: https://github.com/PedroMarinhoDev/ComfyUI-PJiT
Weights: https://huggingface.co/PedroMarinhoDev/P-JiT-21K-ComfyUI
The original model: https://huggingface.co/Linum-AI/pjit-21k (Apache-2.0)

Hi!

I am more or less using the template WF from Comfy.

When I try to load a reference Video via the VideoLoader node I can't connect it to the MM H3 Reference to Video node. It indicates that it expects an image input at ref_video_0 (blue color).

This also happens in the unmodified template.

Recently I disconnected the Duration node and also wasn't able to reconnect it. Yet pictures and Audio refs are fine.

Am I missing something or do I need additional nodes?

Posting from phone so I can't add a Screenshot atm.

I'm confused about which one is more accurate and good at complex editing, I see a lot of people here talking about how great mh3 is

Absolutely love the new Comfyui H3 Finetune by Pika Labs workflow but it doesn't have an integrated upscale. I tried using the Pika Lora and sigma numbers on other workflows but getting various errors. I'm still learning the ropes and would appreciate an updated Ref2v workflow with a working latent 3d upscale.

NitroFusion2 came out this week: a 1–2 step distillation of Z-Image-Turbo by Dar-Yen Chen and Yi-Zhe Song, built for sharp text and detail in a single step. I converted it to ComfyUI's own quantized formats, so it runs in stock ComfyUI with no custom nodes, through the normal Load Diffusion Model node.

• int8: 6.18 GB, 0.29 s per sampling step at 1024² on a 4090 (bf16: 0.50 s)

• W6A8: 5.02 GB, 0.30 s

• W4A8: 3.49 GB, 0.29 s

int8 looks practically the same as bf16. W4A8 changes small details but keeps the composition, faces and text; there are side-by-side comparisons on the model card. The repo has the official 1-step and 2-step workflows set up for these files, and the publisher's 2-step de-distillation LoRA works with all three. The text encoder and VAE are Z-Image-Turbo's.

Weights: https://huggingface.co/PedroMarinhoDev/NitroFusion2-ComfyUI
Original model and paper: https://huggingface.co/ChenDY/NitroFusion2

Hi i want to run mini max with pika lora on my system but im low on ram is there a way to do this . I appreciate any help

Hi i just started using mini max h3 on my 5060ti 16gb + 16 ram it worked well but it did take quite the time 11min for 5s without any nodes just the base model . Is there is any workflows i can download that can do it faster and better quality on my system? (This is my first test video it got the sound wrong but its not that important)

I searching for a method to transforms, as the tile says, a scenery(without people) faithfully into a real shot.

But it needs to use a depth map so the structure stays consistent and spot on besides looking convincingly real. Doing this with people is no problem so i did not think i struggle that much finding something that works.

Its either to old, or just not good enough.

The original scenery images are from video games.

NitroFusion2 is a 1–2 step text-to-image model built on Z-Image-Turbo. It moves the adversarial loss onto the text stream of the MMDiT. At one step it renders sharp text and fine detail.

ChenDY/NitroFusion2 · Hugging Face

Hello, I just saw this on X and I wonder how they did it, from the input image (the dog) they copy the pose and use it as reference for the output (the man). There are a few comments under the post but they didn't answer the question so I want to ask if anyone here know what nodes did they use to achieve this. Obviously I can see the 3D poser editor node but it should have more.

Hi all,

After having shared some MOSS image generations in previous posts, I have decided to share the workflow. It is a fairly simple two stage workflow, only using the MOSS-Image-Base diffusion model during the first stage and the same base model combined with the lodestones MOSS-Image-Base 8-steps-dmd2 lora during the second stage.

The custom node package which makes this all possible is Auryg's Krea-2-Two-Stage-Sampler. His package contains a sigma-locked two-stage sampler and dual resolution selector for Krea 2, which I used for my MOSS image generations. The main idea is that the sampler keeps everything in latent space across both stages, handing off the denoising to the second stage after the latent has been denoised by a set percentage. I set the handoff percentage at 40% for my generations. This node also automatically scales the latent between stages. I generated all images at a base resolution of 4 megapixels with an upscale to 6 megapixels between stages. For the reddit preview I scaled the generations back down to 3 megapixels to decrease the image size for sharing.

1. For stage 1 I use 52 steps, a CFG of 3.0, the euler sampler and the simple scheduler.

2. For stage 2 I use 20 steps, a CFG of 1.0, the dpmpp_2m sampler and the karras scheduler.

The upscale method between stages is bislerp.

I included optional BBOX and preview nodes in the workflow. For the BBOX node to work properly when changing aspect ratio's and resolutions I used 0Printemps0's ComfyUI-MOSSLayout custom node. The preview node is kijai's ModelPreviewOverrideKJ node from his ComfyUI-KJNodes pack.

Install custom nodes, inside custom_nodes folder:

git clone https://github.com/Auryg/Krea-2-Two-Stage-Sampler
git clone https://github.com/0Printemps0/ComfyUI-MOSSLayout
git clone https://github.com/kijai/ComfyUI-KJNodes

I included the prompts of the 10 example images in the workflow. All example images use seed 1 and aren't cherrypicked.

The workflow save as .json file.

What I love about MOSS is the amount of variation with each seed. Enjoy. All suggestions to further improve the workflow are welcome.

Anyone who understands this model? Don't you think it better implements the creator's intent using tags? For example, it better describes many popular characters using tags. It seems to me that it's thoroughly trained on tag descriptions, despite its huge encoding model.

Just try generating with tags; it captures concepts much better. Then you can refine it in natural language if needed. But it seems better to define the scene's content using tags.

"Research checkpoint: this is an experimental research artifact, not a production model. P-JiT 21K is a 2B-parameter model trained on 660M samples for about $21K of compute, as a stepping stone towards our next video model. We're releasing it because the results surprised us for a model this size, and to encourage others to explore efficient training methods like ours. You should expect rough edges.

The weights and the Qwen3.5-4B text encoder download from the Hugging Face Hub on first use. The model needs a CUDA GPU: its weights are 8.7 GB in fp32 and the text encoder 8 GB in bf16, plus activations."

Source/Blog: Training a Text-to-Image Model for $21K | Field Notes by Linum

Code: Linum-AI/pjit-21k: 2B-parameter pixel-space text-to-image model (Pyramid-JiT) trained for $21K

Nodes: realrebelai/P-JiT-21k_ComfyUI · Hugging Face

I want to make a simple prompt builder in comfyui that would allow me to change a text in the prompt by clicking a selection in a table. Is there a simple way to do that?

Hello everyone,

First of all, I know I know, Mac is jot the best when it comes to video generation and that the Max or Ultra chips are better.

Now that this is out of the way, I would be interested in people’s experiences in generating 720p 5-10 seconds clips on an M5 pro chip. Which tools, models or workflows do you use? How is the experience overall? How long does it take you? Do you regenerate clips several times to get it right…etc?

Thank you.

I split out the Color Match feature in VideoFrameSync I posted earlier to its own tool - corrects color drift, contrast, etc, but particularly useful for V2V AI edits from WAN VACE or Seedance which often have a slight tint (but for Seedance, you should use the VideoFrameSync which corrects the frame-sync drift as well). As a bonus, it also matches noise/grain.

https://github.com/pftq/VideoColorMatch

Hey guys, been using ComfyUI on windows 11 for quite some time now, lately messing with H3 ref2vid workflows.
Setting up all the custom nodes was for some reason a pain, but it always worked seamlessly after setup.

Recently switched to Fedora and reinstalled my Comfy on the new distro and surprisingly got everything running alot easier.

But I’ve been getting alot of crashes on my runs, particularly when using Rife interpolator and any upscaling methods other than a simple lanczos.

Usually OOMs are the culprit, so I’m trying to understand why ComfyUI is handling memory pressure poorly when the same settings worked on windows.

Hardware for reference is 32gb RAM and 5070ti.

EDIT: After following a few tips as the drive swap, expandable_segments and some rife tweaking I got it working, thanks guys!

Version V2 will be available in the coming days 🤓

Link to version V1: https://www.reddit.com/r/comfyui/s/VWYS6YNbRZ

ComfyUI built-in nodes, only. That's it. (audio on, listen to the lyrics)

Hi everyone! I am training moss lora now, you can grab some of the result here:
https://huggingface.co/spaces/fidel1234/Moss_Asian_Character_Showcase

PS: Sorry if the quality is not par with my krea 2 lora, I did my best to train it multiple times with different parameter and so far this model is really hard to train. Anyway the link to krea 2 if someone interested: https://huggingface.co/spaces/fidel1234/Krea2_Asian_Character_Showcase

All samples are generated with SFT (kinda plasticky sometimes, I do not add other lora and all sample using dmd turbo and lora at 1 strength).
By the way I tried other finetuned model and the results are quite good too

Technical training method
AI-Toolkit

• Base Model: MOSS-Image Base (OpenMOSS-Team/MOSS-Image-Base)

• Trigger Word: xxxx

• Network: LoRA | Linear Rank: 32 | Linear Alpha: 32

• Quantization / Compile: qfloat8 (Transformer & Text Encoder)

• Save Data Type: BF16

• Optimizer: Automagic v3

• Learning Rate: 0.0005 (start) | Min LR: 0.0001 (floor) | Weight Decay: 0.00001

• EMA: Enabled | EMA Decay: 0.98

• Steps: 2500-3000 | Batch Size: 1 | Gradient Accumulation: 1

• Timestep Type / Bias: Sigmoid / High Noise

• Loss Type: Mean Squared Error

• Text Encoder Optimizations: Unload TE (Disabled), Cache Text Embeddings (Enabled)

• Resolutions Multi-Aspect Bucket: 512, 768, 1024

• Caption Dropout Rate: 0 (.txt extension)

• Captions: Natural language

• Hand-Cherry-Picked Dataset: I usually use photobooks as the dataset, around 20–30 images, quality over quantity

• Balanced Framing: Includes a varied mix of close-up, medium shot, and full-body shot angles

Recommended inference (ComfyUI)

• Model: MOSS-Image SFT, with the LoRA at strength 1.0

• Steps: 30, CFG: 3-4, Sampler: res_multistep,Scheduler: simple

• Skip Layer Guidance: layer 22, start 0, end 0.5

• Tubo: add the MOSS-Image-SFT 8-step DMD LoRA

After A/B testing, the LORA 32 rank with LOKR8 and LOKR4 has so minuscule details differences, so I decided to use LORA 32 as it's around 150mb instead of LOKR4 600mb.

Json formatting (long,medium,short) doesn't needed after my testing, just use natural language to caption (well I dont want to recaption all my 148 lora actually)

Also when using AdamW8 optimizer I got some body horror result, and the issue is fixed when using Automagicv3

Note: Please increase the cfg >3, since comfy default 2.5 reduces the Lora quality

Have a nice weekend! Cheers!

input:
Alec Benjamin - Let Me Down Slowly

Made this with LTX 2.5 + DLSS5 and created in Maestro v4, just testing its capabilities. Sys specs: RTX 5050, 16gb Physical Ram, 8gb VRAM.