MobilePicasso: Efficient 4K Mobile Diffusion Editing

• MobilePicasso is a high-resolution image editing system that employs a three-stage hybrid pipeline to perform 4K diffusion-based synthesis on mobile devices.
• It combines hallucination-aware loss at standard resolution, a learnable latent projection for efficient upscaling, and adaptive context-preserving tiling to reduce artefacts.
• Empirical results demonstrate up to 55.8× speed-up over on-device baselines with strong quality improvements and minimal additional memory usage.

MobilePicasso is a high-resolution image editing system for mobile devices that uses diffusion models to perform image-to-image synthesis at resolutions up to 4K while minimizing computational cost and memory usage (Kwon et al., 7 Oct 2025). Its central design is a three-stage hybrid pipeline: image editing at a standard resolution with hallucination-aware loss, learnable latent projection that avoids returning to pixel space, and adaptive context-preserving tiling for high-resolution upscaling. The system is motivated by the tension between the quality of contemporary diffusion-based editing and the practical constraints of mobile hardware, especially RAM limits, latency, and privacy-sensitive deployment.

1. Problem setting and system objectives

MobilePicasso targets a specific regime of diffusion-based image editing: high-resolution output on resource-constrained devices such as phones, tablets, and TVs, in settings where user privacy and low-latency interaction are critical (Kwon et al., 7 Oct 2025). The motivating observation is that high-resolution diffusion inference is typically incompatible with mobile deployment. Resolutions over $1024 \times 1024$ are described as problematic because of Out-Of-Memory errors, and existing high-resolution baselines can be slow even on server hardware; the paper notes that DemoFusion can take 9 minutes on an A100 GPU for 4K images.

The paper identifies three primary obstacles. The first is memory pressure, since naive high-resolution diffusion inference scales poorly. The second is computation, because tiling-based methods reduce memory but incur computational overhead that scales quadratically with overlap. The third is image quality, especially hallucination: unwanted artefacts, objects, or glitches that become more pronounced at higher resolutions or under tiling. The reported figure that up to 30% of images in standard test sets are affected by hallucinations gives this issue a central role in the system design.

This framing places MobilePicasso at the intersection of mobile systems optimization and diffusion-based generative modeling. Rather than attempting a monolithic 4K diffusion pass, it decomposes the problem into sub-tasks that are more tractable on mobile hardware. This suggests that the contribution is as much architectural as algorithmic.

2. Three-stage hybrid pipeline

MobilePicasso comprises three stages, each assigned a distinct role in the high-resolution editing workflow (Kwon et al., 7 Oct 2025).

Stage	Operation	Stated purpose
1	Image editing at $512 \times 512$ with hallucination-aware loss	Use the resolution where DMs are natively effective and less likely to generate hallucinations or OOM
2	Learnable latent projection	Overcome going to the pixel space
3	Adaptive Context-Preserving Tiling (ACPT)	Efficient high-resolution upscaling with reduced artefacts

In Stage 1, image editing is performed at the standard resolution of $512 \times 512$. The rationale is that diffusion models are natively effective at this scale and less likely to trigger hallucinations or OOM. A hallucination-aware loss is introduced at this stage to regularize generation further.

In Stage 2, the edited latent is upscaled by a lightweight learnable projection in latent space. Instead of decoding the edited image to pixels, upscaling it, and then re-encoding it, MobilePicasso projects the low-resolution edited latent directly into a higher-resolution latent representation. The stated purpose is to avoid the cost of “going to the pixel space.”

In Stage 3, the higher-resolution latent is processed with a super-resolution model using Adaptive Context-Preserving Tiling (ACPT). This stage is designed to fit high-resolution processing into mobile memory budgets while avoiding visible seams and minimizing the overhead associated with conventional overlapping tiling.

The overall pipeline is therefore hybrid in two senses: it separates semantic editing from high-resolution reconstruction, and it combines latent-space operations with tile-based spatial decomposition. The paper treats this decomposition as the main systems innovation behind practical 4K editing on mobile NPUs.

3. Training formulation and hallucination-aware loss

MobilePicasso uses a diffusion-model training formulation in latent space and augments it with hallucination-aware regularization (Kwon et al., 7 Oct 2025). The paper gives the base diffusion objective as

$$\mathbb{E}_{\epsilon, t}\left[\left\|\epsilon-f_\theta\left(\mathbf{z}_t, t\right)\right\|\right]$$

with latent noise scheduling

$$\mathbf{z}_t = \alpha_t\mathbf{z} + \sigma_t\epsilon.$$

It also specifies a classifier-free guidance formulation:

$$\begin{align*} g_\theta(z_t, t, c_I, c_T) &:= f_\theta(z_t, t, \emptyset, \emptyset) \ &+ s_I\left(f_\theta(z_t, t, c_I, \emptyset) - f_\theta(z_t, t, \emptyset, \emptyset)\right) \ &+ s_T\left(f_\theta(z_t, t, c_I, c_T) - f_\theta(z_t, t, c_I, \emptyset)\right) \end{align*}$$

where $s_I$ and $s_T$ control fidelity and alignment.

The distinctive addition is the hallucination-aware loss, defined through a hallucination detection model $\mathcal{M}$ applied to the decoded output:

$$\begin{gathered} L_\text{LDM}=\mathbb{E}_{\epsilon \sim \mathcal{N}(0,1), t, y}\left[\| \epsilon - \epsilon_{\theta}(z_t, t, c_I, c_T) \|_2^2\right] \ L_\text{Hallu}=\mathbb{E}_{\epsilon \sim \mathcal{N}(0,1), t, y}\left[\| \mathcal{M} (\mathcal{D}(g_{\theta}(z_t, t, c_I, c_T))) \|_2^2\right] \ L = L_\text{LDM} + \lambda \cdot L_\text{Hallu} \end{gathered}$$

Here, $512 \times 512$0 is the VAE decoder and $512 \times 512$1 controls the strength of the hallucination penalty. The detector’s output is interpreted as hallucination area, and that quantity is penalized during training.

The reported effect is twofold. Hallucination-aware loss alone yields a 2.2% improvement in Table 1, and when combined with data filtering it produces about 20% improvement across objective quality metrics. In the user study, human raters report a 14–51% reduction in hallucinations relative to previous methods. The training objective is thus not only generative but explicitly corrective with respect to failure modes that become prominent at high resolution.

4. Latent projection and Adaptive Context-Preserving Tiling

The second and third stages implement the core efficiency mechanisms of MobilePicasso (Kwon et al., 7 Oct 2025). The latent projection module addresses a common inefficiency in high-resolution editing pipelines: decode $512 \times 512$2 upscale $512 \times 512$3 re-encode. The paper argues that this pixel-space route introduces both memory/computation overhead and quality degradation, including blur, artefacts, and disruption of latent semantic structure.

To avoid this, MobilePicasso uses a tiny autoencoder with 1.2M parameters and a learnable lightweight convolutional block to project the edited low-resolution latent directly into high-resolution latent space. The paper reports that this module is 68$512 \times 512$4 smaller and 280–853$512 \times 512$5 faster than traditional decode–upsample–encode approaches. It is also described as maintaining semantic consistency during upscaling better than bilinear or bicubic upsampling.

ACPT addresses the separate problem of tile boundaries. Standard overlap-based tiling improves quality but incurs cost that scales quadratically with overlap. MobilePicasso instead introduces Adjacent Padding, in which each tile is padded with actual pixels from adjacent tiles rather than zeros or self-reflection. This preserves context even with 0% overlap when the image dimensions are divisible by tile size. For non-divisible sizes, a minimal adaptive overlap is used, following the rule

$512 \times 512$6

This design is intended to eliminate seams while avoiding the cost of large overlaps. Quantitatively, ACPT achieves 3.12$512 \times 512$7 speedup versus 50% overlap tiling. In quality terms, it reaches 19.73 dB PSNR versus 19.78 dB for 50% overlap, corresponding to 99.7% of the “upper bound,” and 0.5389 SSIM versus 0.5470, or 98.5% of the “upper bound.” A common assumption in tiled high-resolution synthesis is that overlap is the main route to seamlessness; MobilePicasso’s results are presented as evidence that context-preserving padding can largely decouple seam suppression from overlap cost.

5. Empirical results: quality, latency, and memory

The evaluation combines user study results, objective metrics, and systems benchmarks (Kwon et al., 7 Oct 2025). The user study involves 46 participants, compares four systems—MobilePicasso, IP2P, MagicBrush, and PIPE—and collects 5,888 ratings. Relative to baselines, MobilePicasso reports +18–48% on image quality, +22–54% on text alignment, and +14–51% on resilience to hallucination. One concrete example given is that on “Image Quality,” IP2P scores 3.73 while MobilePicasso scores 4.40 out of 5.

On the MagicBrush test set, MobilePicasso achieves the lowest L1/L2 and the highest CLIP-I, DINO, and CLIP-T scores. The paper also reports that data filtering alone adds ~17.8% improvement over the previous state-of-the-art, and that the combination of hallucination-aware loss and data filtering outperforms prior art by an average of 20% across six metrics.

The systems results are especially central because the work is framed around mobile feasibility.

Configuration	Latency for 4K editing	Peak memory
Baseline with 50% overlap tiling (on-device)	2,340 s	1.06 GB
Baseline with 25% overlap (on-device)	1,201 s	—
MobilePicasso (on-device)	42 s	1.15 GB
Server-based baseline without tiling on A100 GPU	197 s	76.2 GB

The paper summarizes this as up to 55.8$512 \times 512$8 speed-up over prior on-device baselines, with only a 9% increase in runtime memory over prior tiled approaches. It also notes that the speed-up decomposes into 3.12$512 \times 512$9 from ACPT, 15.35$512 \times 512$0 from the 3-stage hybrid pipeline, and 1.16$512 \times 512$1 from latent projection, with multiplicative combination approximately matching the full acceleration. A striking result is that the on-device runtime of MobilePicasso is reported as faster than a server-based high-resolution model running on an A100 GPU.

6. Position within mobile image editing research

MobilePicasso is presented as a response to limitations in several prior categories of work (Kwon et al., 7 Oct 2025). Against naive tiling-based editing, it is designed to reduce visible seams, stronger hallucinations, excessive computational overhead, and OOM failures at 4K. Against server-based high-resolution editing without tiling, it emphasizes that cloud-scale memory and compute are incompatible with on-device deployment. Against IP2P, MagicBrush, and PIPE, it reports fewer hallucinations and higher quality at both standard and high resolutions. Against the alternative Cheap Scaling method, it contrasts lower latency on GPU with much higher memory demand: 53 GB at 2K and more than 80 GB OOM at 4K.

The paper explicitly characterizes MobilePicasso as the first practical system to bring high-resolution (4K) diffusion-based image editing to mobile devices with superior image quality and text alignment, up to 51% reduction in hallucinations in human evaluation, and a minimal additional memory requirement of 9% at 1.15 GB peak RAM. Within the broader mobile visual computing literature, this emphasis on hybrid decomposition has precedent: earlier mobile pipelines for related generation tasks, such as GPU-accelerated mobile multi-view style transfer, also separated a costly transformation stage from geometry-aware synthesis and post-processing to obtain near-constant latency scaling on mobile GPUs (Kohli et al., 2020). A plausible implication is that MobilePicasso extends this mobile-systems pattern into diffusion-based high-resolution editing.

A second plausible implication emerges when MobilePicasso is read alongside later on-device diffusion editors such as BlazeEdit, which removes text-conditioning and concentrates on standard-resolution image-and-mask editing in a compact 195M-parameter model (Deng et al., 27 May 2026). In that juxtaposition, MobilePicasso represents the high-resolution, text-guided branch of mobile diffusion editing, whereas BlazeEdit represents a compact generalist branch optimized for fully on-device image-to-image editing without text. The two works therefore occupy complementary points in the design space rather than directly interchangeable ones.