@@ -587,6 +587,8 @@
         title: PixArt-Σ
       - local: api/pipelines/prx
         title: PRX
+      - local: api/pipelines/prx_pixel
+        title: PRX Pixel
       - local: api/pipelines/qwenimage
         title: QwenImage
       - local: api/pipelines/sana
 
@@ -671,6 +671,7 @@
             "PixArtSigmaPAGPipeline",
             "PixArtSigmaPipeline",
             "PRXPipeline",
+            "PRXPixelPipeline",
             "QwenImageControlNetInpaintPipeline",
             "QwenImageControlNetPipeline",
             "QwenImageEditInpaintPipeline",
@@ -1491,6 +1492,7 @@
             PixArtSigmaPAGPipeline,
             PixArtSigmaPipeline,
             PRXPipeline,
+            PRXPixelPipeline,
             QwenImageControlNetInpaintPipeline,
             QwenImageControlNetPipeline,
             QwenImageEditInpaintPipeline,
 
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any
+from typing import Any, Optional
 
 import torch
 from torch import nn
@@ -321,6 +321,48 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
         return self.out_layer(self.silu(self.in_layer(x)))
 
 
+class PRXResolutionEmbedder(nn.Module):
+    r"""
+    Embeds the spatial resolution `(height, width)` of the latent into a vector that is added to the timestep
+    embedding, so the model can condition its modulation on the generation resolution.
+
+    A sinusoidal embedding of dimension 128 is built for the height and the width separately and concatenated into a
+    256-dim vector, which is then projected to `hidden_size` by a 2-layer MLP. This matches the `"vec"` mode of the
+    resolution-aware conditioning used during PRX-7B training.
+
+    Args:
+        hidden_size (`int`):
+            Dimension of the output embedding (must match the timestep embedding dimension).
+        max_period (`int`, *optional*, defaults to 10000):
+            Maximum frequency period for the sinusoidal resolution embedding.
+    """
+
+    def __init__(self, hidden_size: int, max_period: int = 10000):
+        super().__init__()
+        self.max_period = max_period
+        self.mlp = MLPEmbedder(in_dim=256, hidden_dim=hidden_size)
+
+    def forward(self, height: torch.Tensor, width: torch.Tensor, dtype: torch.dtype) -> torch.Tensor:
+        h_emb = get_timestep_embedding(
+            timesteps=height,
+            embedding_dim=128,
+            max_period=self.max_period,
+            scale=1.0,
+            flip_sin_to_cos=True,
+            downscale_freq_shift=0.0,
+        )
+        w_emb = get_timestep_embedding(
+            timesteps=width,
+            embedding_dim=128,
+            max_period=self.max_period,
+            scale=1.0,
+            flip_sin_to_cos=True,
+            downscale_freq_shift=0.0,
+        )
+        hw_emb = torch.cat([h_emb, w_emb], dim=-1).to(dtype)
+        return self.mlp(hw_emb)
+
+
 class Modulation(nn.Module):
     r"""
     Modulation network that generates scale, shift, and gating parameters.
@@ -613,12 +655,19 @@ class PRXTransformer2DModel(ModelMixin, ConfigMixin, AttentionMixin):
             Scaling factor applied in timestep embeddings.
         time_max_period (`int`, *optional*, defaults to 10000):
             Maximum frequency period for timestep embeddings.
+        bottleneck_size (`int`, *optional*):
+            If set, the image patch projection (`img_in`) uses a two-layer bottleneck (`patch_dim -> bottleneck_size ->
+            hidden_size`) instead of a single linear layer. Used by the pixel-space PRX-7B variant where the patch
+            dimension is large.
+        resolution_embeds (`bool`, *optional*, defaults to `False`):
+            Whether to condition the timestep modulation on the latent resolution `(H, W)` via a
+            `PRXResolutionEmbedder`. Used by the PRX-7B variant.
 
     Attributes:
         pe_embedder (`EmbedND`):
             Multi-axis rotary embedding generator for positional encodings.
-        img_in (`nn.Linear`):
-            Projection layer for image patch tokens.
+        img_in (`nn.Linear` or `nn.Sequential`):
+            Projection layer for image patch tokens (a two-layer bottleneck when `bottleneck_size` is set).
         time_in (`MLPEmbedder`):
             Embedding layer for timestep embeddings.
         txt_in (`nn.Linear`):
@@ -666,6 +715,8 @@ def __init__(
         theta: int = 10000,
         time_factor: float = 1000.0,
         time_max_period: int = 10000,
+        bottleneck_size: Optional[int] = None,
+        resolution_embeds: bool = False,
     ):
         super().__init__()
 
@@ -691,10 +742,22 @@ def __init__(
         self.hidden_size = hidden_size
         self.num_heads = num_heads
         self.pe_embedder = PRXEmbedND(dim=pe_dim, theta=theta, axes_dim=axes_dim)
-        self.img_in = nn.Linear(self.in_channels * self.patch_size**2, self.hidden_size, bias=True)
+        patch_dim = self.in_channels * self.patch_size**2
+        if bottleneck_size is not None:
+            # Two-layer bottleneck projection (used by pixel-space PRX where the patch dimension is large).
+            self.img_in = nn.Sequential(
+                nn.Linear(patch_dim, bottleneck_size, bias=True),
+                nn.Linear(bottleneck_size, self.hidden_size, bias=True),
+            )
+        else:
+            self.img_in = nn.Linear(patch_dim, self.hidden_size, bias=True)
         self.time_in = MLPEmbedder(in_dim=256, hidden_dim=self.hidden_size)
         self.txt_in = nn.Linear(context_in_dim, self.hidden_size)
 
+        self.resolution_embedder = (
+            PRXResolutionEmbedder(self.hidden_size, max_period=time_max_period) if resolution_embeds else None
+        )
+
         self.blocks = nn.ModuleList(
             [
                 PRXBlock(
@@ -771,6 +834,13 @@ def forward(
         # Compute time embedding
         vec = self._compute_timestep_embedding(timestep, dtype=img.dtype)
 
+        # Add resolution conditioning (PRX-7B "vec" mode): embed the latent (H, W) and add it to the timestep vector
+        # so every block's modulation is resolution-aware.
+        if self.resolution_embedder is not None:
+            height = torch.full((bs,), h, device=hidden_states.device, dtype=torch.float32)
+            width = torch.full((bs,), w, device=hidden_states.device, dtype=torch.float32)
+            vec = vec + self.resolution_embedder(height, width, dtype=vec.dtype)
+
         # Apply transformer blocks
         for block in self.blocks:
             if torch.is_grad_enabled() and self.gradient_checkpointing:
 
@@ -193,7 +193,7 @@
         "FluxKontextPipeline",
         "FluxKontextInpaintPipeline",
     ]
-    _import_structure["prx"] = ["PRXPipeline"]
+    _import_structure["prx"] = ["PRXPipeline", "PRXPixelPipeline"]
     _import_structure["audioldm2"] = [
         "AudioLDM2Pipeline",
         "AudioLDM2ProjectionModel",
@@ -848,7 +848,7 @@
             StableDiffusionXLPAGPipeline,
         )
         from .pixart_alpha import PixArtAlphaPipeline, PixArtSigmaPipeline
-        from .prx import PRXPipeline
+        from .prx import PRXPipeline, PRXPixelPipeline
         from .qwenimage import (
             QwenImageControlNetInpaintPipeline,
             QwenImageControlNetPipeline,
 
@@ -23,6 +23,7 @@
     _dummy_objects.update(get_objects_from_module(dummy_torch_and_transformers_objects))
 else:
     _import_structure["pipeline_prx"] = ["PRXPipeline"]
+    _import_structure["pipeline_prx_pixel"] = ["PRXPixelPipeline"]
 
 # Wrap T5GemmaEncoder to pass config.encoder (T5GemmaModuleConfig) instead of the
 # composite T5GemmaConfig, which lacks flat attributes expected by T5GemmaEncoder.__init__.
@@ -57,6 +58,7 @@ def from_pretrained(cls, pretrained_model_name_or_path, *args, **kwargs):
     else:
         from .pipeline_output import PRXPipelineOutput
         from .pipeline_prx import PRXPipeline
+        from .pipeline_prx_pixel import PRXPixelPipeline
 
 else:
     import sys
 
@@ -230,6 +230,12 @@ def clean_text(self, text: str) -> str:
 
         return text.strip()
 
+    def basic_clean(self, text: str) -> str:
+        """Light cleaning: fix mojibake and unescape HTML. Used when skip_text_cleaning=True."""
+        text = ftfy.fix_text(text)
+        text = html.unescape(html.unescape(text))
+        return text.strip()
+
 
 EXAMPLE_DOC_STRING = """
     Examples:
@@ -378,6 +384,8 @@ def encode_prompt(
         negative_prompt_embeds: torch.FloatTensor | None = None,
         prompt_attention_mask: torch.BoolTensor | None = None,
         negative_prompt_attention_mask: torch.BoolTensor | None = None,
+        tokenizer_max_length: int | None = None,
+        skip_text_cleaning: bool = False,
     ):
         """Encode text prompt using standard text encoder and tokenizer, or use precomputed embeddings."""
         if device is None:
@@ -388,7 +396,14 @@ def encode_prompt(
                 prompt = [prompt]
             # Encode the prompts
             prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask = (
-                self._encode_prompt_standard(prompt, device, do_classifier_free_guidance, negative_prompt)
+                self._encode_prompt_standard(
+                    prompt,
+                    device,
+                    do_classifier_free_guidance,
+                    negative_prompt,
+                    tokenizer_max_length=tokenizer_max_length,
+                    skip_text_cleaning=skip_text_cleaning,
+                )
             )
 
         # Duplicate embeddings for each generation per prompt
@@ -419,13 +434,21 @@ def encode_prompt(
             negative_prompt_attention_mask if do_classifier_free_guidance else None,
         )
 
-    def _tokenize_prompts(self, prompts: list[str], device: torch.device):
+    def _tokenize_prompts(
+        self,
+        prompts: list[str],
+        device: torch.device,
+        tokenizer_max_length: int | None = None,
+        skip_text_cleaning: bool = False,
+    ):
         """Tokenize and clean prompts."""
-        cleaned = [self.text_preprocessor.clean_text(text) for text in prompts]
+        clean_fn = self.text_preprocessor.basic_clean if skip_text_cleaning else self.text_preprocessor.clean_text
+        cleaned = [clean_fn(text) for text in prompts]
+        max_length = tokenizer_max_length or self.tokenizer.model_max_length
         tokens = self.tokenizer(
             cleaned,
             padding="max_length",
-            max_length=self.tokenizer.model_max_length,
+            max_length=max_length,
             truncation=True,
             return_attention_mask=True,
             return_tensors="pt",
@@ -438,6 +461,8 @@ def _encode_prompt_standard(
         device: torch.device,
         do_classifier_free_guidance: bool = True,
         negative_prompt: str = "",
+        tokenizer_max_length: int | None = None,
+        skip_text_cleaning: bool = False,
     ):
         """Encode prompt using standard text encoder and tokenizer with batch processing."""
         batch_size = len(prompt)
@@ -450,7 +475,9 @@ def _encode_prompt_standard(
         else:
             prompts_to_encode = prompt
 
-        input_ids, attention_mask = self._tokenize_prompts(prompts_to_encode, device)
+        input_ids, attention_mask = self._tokenize_prompts(
+            prompts_to_encode, device, tokenizer_max_length=tokenizer_max_length, skip_text_cleaning=skip_text_cleaning
+        )
 
         with torch.no_grad():
             embeddings = self.text_encoder(
@@ -501,10 +528,12 @@ def check_inputs(
                 "`negative_prompt_embeds` must also be provided for classifier-free guidance."
             )
 
-        spatial_compression = self.vae_scale_factor
-        if height % spatial_compression != 0 or width % spatial_compression != 0:
+        # The latents must be divisible by the transformer's patch size after VAE compression.
+        dimension_multiple = self.vae_scale_factor * self.transformer.config.patch_size
+        if height % dimension_multiple != 0 or width % dimension_multiple != 0:
             raise ValueError(
-                f"`height` and `width` have to be divisible by {spatial_compression} but are {height} and {width}."
+                f"`height` and `width` have to be divisible by {dimension_multiple} (vae_scale_factor *"
+                f" transformer patch_size) but are {height} and {width}."
             )
 
         if guidance_scale < 1.0:
@@ -545,6 +574,8 @@ def __call__(
         use_resolution_binning: bool = True,
         callback_on_step_end: Callable[[int, int], None] | None = None,
         callback_on_step_end_tensor_inputs: list[str] = ["latents"],
+        tokenizer_max_length: int | None = None,
+        skip_text_cleaning: bool = False,
     ):
         """
         Function invoked when calling the pipeline for generation.
@@ -598,6 +629,12 @@ def __call__(
             output_type (`str`, *optional*, defaults to `"pil"`):
                 The output format of the generate image. Choose between
                 [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
+            tokenizer_max_length (`int`, *optional*):
+                Override the maximum number of tokens used when tokenizing the prompt. Defaults to the tokenizer's own
+                ``model_max_length`` when not set.
+            skip_text_cleaning (`bool`, *optional*, defaults to `False`):
+                If `True`, uses only light prompt cleaning (fix encoding + unescape HTML) instead of the full DeepFloyd
+                cleaning pipeline.
             return_dict (`bool`, *optional*, defaults to `True`):
                 Whether or not to return a [`~pipelines.prx.PRXPipelineOutput`] instead of a plain tuple.
             use_resolution_binning (`bool`, *optional*, defaults to `True`):
@@ -627,11 +664,6 @@ def __call__(
         width = width or default_resolution
 
         if use_resolution_binning:
-            if self.image_processor is None:
-                raise ValueError(
-                    "Resolution binning requires a VAE with image_processor, but VAE is not available. "
-                    "Set use_resolution_binning=False or provide a VAE."
-                )
             if self.default_sample_size not in ASPECT_RATIO_BINS:
                 raise ValueError(
                     f"Resolution binning is only supported for default_sample_size in {list(ASPECT_RATIO_BINS.keys())}, "
@@ -684,6 +716,8 @@ def __call__(
             negative_prompt_embeds=negative_prompt_embeds,
             prompt_attention_mask=prompt_attention_mask,
             negative_prompt_attention_mask=negative_prompt_attention_mask,
+            tokenizer_max_length=tokenizer_max_length,
+            skip_text_cleaning=skip_text_cleaning,
         )
         # Expose standard names for callbacks parity
         prompt_embeds = text_embeddings