Introduction

Text-to-image diffusion models have revolutionized image generation. Given a prompt such as “a person wearing a red jacket standing on a beach,” they can synthesize photorealistic images from pure noise.

Image editing, however, poses a different challenge. Rather than generating a new image, the goal is to modify only the requested attribute while preserving everything else. For example, changing a red jacket to a black shirt should leave the person’s identity, pose, lighting, composition, and background untouched.

Conventional text-to-image models are not designed for this task. Since they are trained to generate images from scratch, every inference starts from random noise and follows a denoising trajectory toward an image matching the prompt. They have no inherent mechanism to preserve the contents of an existing image, so naïvely prompting them with an editing instruction often produces an entirely new image instead of a faithful edit.

Can we transform a text-to-image model into an image editor without retraining it?

In this article, we answer the above question by showing how a pre-trained text-to-image model can be repurposed as an image editor entirely at inference time. Rather than fine-tuning the model or introducing additional trainable components, we leverage inference-time techniques — FlowEdit and FlowAlign — to guide the latent generation trajectory. This enables instruction-guided image editing while preserving the source image, all without modifying the underlying Z-Image model.

To understand how this works, we’ll first look at how Z-Image generates images and why direct editing approaches often fail. We’ll then see how FlowEdit and FlowAlign overcome these limitations, enabling high-fidelity, instruction-guided image editing without any additional training.

Understanding Z-Image

How Z-Image Generates Images

At a high level, Z-Image consists of three components:

• Qwen3–4B, which converts the text prompt into contextual language embeddings.
• Flux VAE, which defines the latent space for image generation and decodes the final latent into an RGB image.
• S3-DiT (Scalable Single-Stream Diffusion Transformer), which progressively transforms a noisy latent into one representing the target image.

From Text to Image

Given a prompt such as “A person wearing a red jacket standing on a beach,” Qwen3–4B first produces contextual text embeddings that condition the image generation process.

Unlike autoregressive language models, Z-Image generates directly in the Flux VAE latent space. Since there is no input image during inference, generation begins from a randomly sampled Gaussian noise latent. This latent, together with the text embeddings, is then fed into S3-DiT.

Flow Matching

Z-Image is trained using Flow Matching, where the model predicts a velocity — the direction in which the current latent should move — rather than the noise itself. Starting from random noise, S3-DiT repeatedly predicts these velocities, and a flow solver integrates them over multiple timesteps, gradually transforming the latent into one that matches the text prompt.

The final latent is then decoded by the Flux VAE decoder to produce the output image.

Our First Attempts at Image Editing

Having understood how Z-Image generates images, the next challenge was adapting it for image editing.

A natural first idea was to provide the model with the source image alongside the editing instruction — the image would specify what to preserve, while the text would specify what to change. Before modifying the generation process itself, we explored several conditioning strategies.

Attempt 1: Conditioning on the Reference Image

We first encoded the source image using SigLIP 2 [4], producing visual tokens that were concatenated with the text embeddings from Qwen3–4B before being passed to S3-DiT. Classifier-free guidance (CFG) was then used to encourage the requested edit.

[ Edit Instruction | Reference Image Features ]

While the model utilized both inputs, the results were inconsistent. Beyond the requested edit, it often altered the subject’s identity, pose, composition, or background. The core issue is that conditioning informs the model what information is available, but not what must remain unchanged. As a result, the image features and editing instruction compete during generation, and CFG can amplify unintended changes.

Attempt 2: Converting the Image into Text

Next, we described the source image using Qwen3-VL [5] and conditioned Z-Image on both the generated caption and the editing instruction.

[ Edit Instruction | Source Image Caption ]

Although this unified both inputs into a single modality, captions are inherently lossy. They capture high-level semantics but omit fine-grained details such as facial identity, pose, spatial layout, lighting, and texture. Consequently, the generated images preserved the overall scene but failed to faithfully reproduce the source image.

Attempt 3: Image-Guided Generation

Finally, we removed the editing instruction entirely and conditioned the model only on the SigLIP 2 image features, while still starting generation from random noise.

The model produced plausible variations of the reference image, preserving its overall subject and style, but the pose, viewpoint, and composition frequently changed. It could generate similar images, but not controlled edits.

The Common Failure

Despite their differences, all three approaches relied on the same assumption: better conditioning should lead to better editing.

In practice, the bottleneck was not the conditioning but the generation trajectory. Once generation begins from random noise, nothing constrains the latent to remain close to the source image. Conditioning influences what the model should generate, but not how the latent evolves over time.

This shifts the problem from improving the input to controlling the generation process itself.

Can we directly modify the generation trajectory instead?

That question leads us to FlowEdit [1].

FlowEdit: Editing the Trajectory Instead of the Conditioning

Our earlier attempts all shared the same limitation: they improved the conditioning, but left the generation process unchanged. Although the model had access to the source image through image features or captions, the latent trajectory could still drift away once denoising began.

FlowEdit takes a different approach. Instead of providing more information to the model, it directly modifies how the latent evolves during generation.

Thinking in Terms of Velocities

Recall that Z-Image is trained using Flow Matching, where the model predicts a velocity at every timestep — the direction in which the current latent should move.

Consider two prompts describing the same scene:

• Source: “A person wearing a black shirt standing on a beach.”
• Target: “A person wearing a red jacket standing on a beach.”

At the same latent point, we query the model twice: once with the source prompt and once with the target prompt. The difference between the two predicted velocities represents the semantic edit direction — the change required to transform the source concept into the target one.

v_src = model(z_t, source prompt)
v_tgt = model(z_t, target prompt)

Steering the Trajectory

The updated velocity is computed as:

v_edit = v_src + α · (v_tgt - v_src)

Here, α controls the edit strength.

Small values of α keep the trajectory close to the source image, while larger values produce stronger edits. In our example, the source velocity preserves the person’s identity, pose, lighting, and background, while the velocity difference gradually replaces the black shirt with a red jacket.

Instead of regenerating the image, FlowEdit performs a sequence of small semantic updates throughout the denoising process.

Why This Works Better

FlowEdit shifts the focus from conditioning to trajectory control. Rather than relying on the model to infer what should be preserved, it explicitly edits the predicted velocity at every flow step, making the generation process itself editable.

Results:

But One Problem Remains

Although FlowEdit greatly improves controllability, it does not fully prevent trajectory drift. Strong editing prompts can gradually pull the latent away from the source image, causing unintended changes such as altered facial identity, pose, or background.

In other words, FlowEdit provides the direction of the edit, but not an explicit mechanism to keep the edited trajectory close to the original one.

This motivates FlowAlign [2], which continuously anchors the edited trajectory to the source trajectory throughout generation.

FlowAlign: Anchoring the Trajectory to the Source Image

FlowAlign addresses the drawbacks of FlowEdit by continuously anchoring the edited trajectory to the source image throughout generation.

Constructing a Reference Trajectory

Recall that during editing we already have access to the source image. Unlike text-to-image generation, where inference begins from random noise, image editing begins with a known image that can be encoded into the same latent space used by Z-Image.

Let z_src be the clean source latent, x_t the current edited latent, σ the current noise level, and ε fresh noise.

q_t = (1 - σ) · z_src + σ · ε

q_t represents the noisy source latent at the current timestep.

The latent q_t can be thought of as the reference point for the source image at the current timestep. Instead of comparing the edited latent to the fully clean source image, FlowAlign compares two latents that exist at the same noise level, making the comparison meaningful throughout the denoising process.

Aligning the Edited Trajectory

The edited latent, denoted by x_t, may already have drifted away from the source trajectory due to the semantic edit introduced by FlowEdit.

Before computing velocity updates, FlowAlign first aligns the edited latent with the source trajectory as follows:

p_t = x_t + q_t - z_src

This simple transformation ensures that both trajectories are represented at a comparable point in the diffusion process before the model predicts their respective velocities.

Predicting Source and Target Velocities

FlowAlign then queries the transformer using both the source and target prompts.

Using the aligned latent p_t, the model predicts

• a velocity conditioned on the target prompt, and
• a velocity conditioned on the source prompt.

Classifier-Free Guidance (CFG) combines these predictions to produce the final editing velocity:

v_pc = transformer(p_t, target prompt)
v_pn = transformer(p_t, source prompt)
v_p  = v_pn + cfg_scale · (v_pc - v_pn)
v_q  = transformer(q_t, source prompt)

At the same time, the transformer predicts another velocity v_q using the noisy source latent q_t and the original source prompt.

Intuitively,

• v_p describes where the edited image wants to go, while
• v_q describes how the original image would naturally evolve.

Preventing Trajectory Drift

The final update contains two separate components.

The first is the familiar FlowEdit update, which moves the latent toward satisfying the editing instruction.

The second is an alignment term, which pulls the edited trajectory back toward the source trajectory whenever the two begin to diverge.

The complete update is:

x_t_new = x_t
        + (σ_next - σ) · (v_p - v_q)
        + λ · (q_t - σ · v_q - p_t + σ · v_p)

The parameter λ controls the strength of this alignment.

• A small λ allows the trajectory to move more freely, producing stronger edits but increasing the risk of structural changes.
• A large λ keeps the edited trajectory tightly anchored to the source image, preserving identity and composition but making edits more conservative.

This creates a natural trade-off between edit strength and content preservation, allowing the user to adjust the behavior depending on the task.

Results:

Building Z-Image Edit

By combining FlowEdit and FlowAlign, Z-Image can be repurposed into a training-free image editor entirely at inference time. FlowEdit introduces the desired semantic change, while FlowAlign preserves the source image by anchoring the latent trajectory. The complete pipeline consists of four steps.

Step 1: Encode the Source Image

The source image is encoded by the Flux VAE into a latent representation, providing the starting point for editing.

Step 2: Define the Edit

The model receives two prompts: a source prompt describing the original image and a target prompt describing the desired edit.

Source: “A person wearing a black shirt standing on a beach.”

Target: “A person wearing a red jacket standing on a beach.”

Ideally, the prompts differ only in the attribute to be modified.

Step 3: Guided Flow Updates

At each flow timestep, Z-Image Edit:

1. Reconstructs the noisy source latent for the current timestep.
2. Predicts source and target velocities using S3-DiT.
3. Applies FlowEdit to compute the semantic edit direction.
4. Applies FlowAlign to keep the trajectory aligned with the source image.

The latent is therefore updated toward the target concept while remaining faithful to the original scene.

Step 4: Decode the Result

After the final flow step, the edited latent is decoded by the Flux VAE to produce the final image. Since all modifications occur during inference, no additional training or fine-tuning is required.

Controlling the Edit

Z-Image Edit exposes two key controls:

• Edit guidance, which determines how strongly the model follows the target instruction.
• Alignment strength (λ), which controls how closely the edited trajectory stays aligned with the source image.

Together, these parameters balance edit strength and content preservation. Stronger alignment is generally preferred for localized edits (e.g., changing clothing color), while larger semantic changes may require stronger edit guidance.

Limitations

Although FlowEdit and FlowAlign enable training-free image editing with pre-trained Z-Image models, they have important limitations. FlowEdit can suffer from structural drift, identity loss, and poor source preservation, particularly for large semantic edits. FlowAlign mitigates these issues by anchoring the editing trajectory to the source image, but it requires multiple flow evaluations and careful hyperparameter tuning, increasing computational cost and reducing robustness across diverse editing tasks.

These challenges motivate a future dedicated image editing model trained from scratch on editing pairs, which could achieve higher edit fidelity, stronger instruction following, and better identity preservation than inference-time approaches.”

Conclusion

Transforming a text-to-image model into an image editor requires more than conditioning on a reference image. As we saw, conditioning alone cannot prevent the generation trajectory from drifting away from the source image.

Z-Image Edit addresses this by controlling the generation process itself. FlowEdit steers the latent toward the desired edit, while FlowAlign keeps the trajectory anchored to the source image, enabling high-quality, instruction-guided editing entirely at inference time — without retraining the underlying model.

The key insight is that effective image editing comes not from changing the model itself, but from controlling its latent generation trajectory.

References

[1] V. Kulikov, M. Kleiner, I. Huberman-Spiegelglas, and T. Michaeli, FlowEdit: Inversion-Free Text-Based Editing Using Pre-Trained Flow Models, Proc. IEEE/CVF International Conference on Computer Vision (ICCV), 2025, pp. 19721–19730.

[2] J. Kim, Y. Hong, J. Park, and J. C. Ye, FlowAlign: Trajectory-Regularized, Inversion-Free Flow-based Image Editing, International Conference on Learning Representations (ICLR), 2026.

[3] Z-Image Team, H. Cai, S. Cao, R. Du, P. Gao, S. Hoi, et al., Z-Image: An Efficient Image Generation Foundation Model with Single-Stream Diffusion Transformer, arXiv:2511.22699, 2025.

[4] Tschannen, M., Gritsenko, A., Wang, X., Naeem, M. F., Alabdulmohsin, I., Parthasarathy, N., … & Zhai, X. (2025). Siglip 2: Multilingual vision-language encoders with improved semantic understanding, localization, and dense features. arXiv preprint arXiv:2502.14786.

[5] Bai, S., Cai, Y., Chen, R., Chen, K., Chen, X., Cheng, Z., … & Zhu, K. (2025). Qwen3-vl technical report. arXiv preprint arXiv:2511.21631.

<hr><p>Repurposing Text-to-Image Models as Image Editing Models was originally published in Glance on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>

```plotly
{
  "data": [
    {
      "x": [1, 2, 3, 4],
      "y": [10, 15, 13, 17],
      "type": "scatter"
    },
    {
      "x": [1, 2, 3, 4],
      "y": [16, 5, 11, 9],
      "type": "scatter"
    }
  ]
}
```

Which generates:

{
  "data": [
    {
      "x": [1, 2, 3, 4],
      "y": [10, 15, 13, 17],
      "type": "scatter"
    },
    {
      "x": [1, 2, 3, 4],
      "y": [16, 5, 11, 9],
      "type": "scatter"
    }
  ]
}

Also another example chart.

```plotly
{
  "data": [
    {
      "x": [1, 2, 3, 4],
      "y": [10, 15, 13, 17],
      "mode": "markers"
    },
    {
      "x": [2, 3, 4, 5],
      "y": [16, 5, 11, 9],
      "mode": "lines"
    },
    {
      "x": [1, 2, 3, 4],
      "y": [12, 9, 15, 12],
      "mode": "lines+markers"
    }
  ],
  "layout": {
    "title": {
      "text": "Line and Scatter Plot"
    }
  }
}
```

This is how it looks like:

{
  "data": [
    {
      "x": [1, 2, 3, 4],
      "y": [10, 15, 13, 17],
      "mode": "markers"
    },
    {
      "x": [2, 3, 4, 5],
      "y": [16, 5, 11, 9],
      "mode": "lines"
    },
    {
      "x": [1, 2, 3, 4],
      "y": [12, 9, 15, 12],
      "mode": "lines+markers"
    }
  ],
  "layout": {
    "title": {
      "text": "Line and Scatter Plot"
    }
  }
}

Lightbox2

PhotoSwipe

Spotlight JS

Venobox

First tabs

To add tabs, use the following syntax:

{% tabs group-name %}

{% tab group-name tab-name-1 %}

Content 1

{% endtab %}

{% tab group-name tab-name-2 %}

Content 2

{% endtab %}

{% endtabs %}

With this you can generate visualizations like:

• php
• js
• ruby

• var_dump('hello');
  

• console.log("hello");
  

• pputs 'hello'
  

Another example

• yaml
• json

• hello:
    - "whatsup"
    - "hi"
  

• {
    "hello": ["whatsup", "hi"]
  }
  

Tabs for something else

• text
• quote
• list

• Regular text

• A quote

• Hipster list

  • brunch
  • fixie
  • raybans
  • messenger bag

```typograms
+----+
|    |---> My first diagram!
+----+
```

Which generates:

+----+
|    |---> My first diagram!
+----+

Another example:

```typograms
.------------------------.
|.----------------------.|
||"https://example.com" ||
|'----------------------'|
| ______________________ |
||                      ||
||   Welcome!           ||
||                      ||
||                      ||
||  .----------------.  ||
||  | username       |  ||
||  '----------------'  ||
||  .----------------.  ||
||  |"*******"       |  ||
||  '----------------'  ||
||                      ||
||  .----------------.  ||
||  |   "Sign-up"    |  ||
||  '----------------'  ||
||                      ||
|+----------------------+|
.------------------------.
```

which generates:

.------------------------.
|.----------------------.|
||"https://example.com" ||
|'----------------------'|
| ______________________ |
||                      ||
||   Welcome!           ||
||                      ||
||                      ||
||  .----------------.  ||
||  | username       |  ||
||  '----------------'  ||
||  .----------------.  ||
||  |"*******"       |  ||
||  '----------------'  ||
||                      ||
||  .----------------.  ||
||  |   "Sign-up"    |  ||
||  '----------------'  ||
||                      ||
|+----------------------+|
.------------------------.

For more examples, check out the typograms documentation.

```pseudocode
% This quicksort algorithm is extracted from Chapter 7, Introduction to Algorithms (3rd edition)
\begin{algorithm}
\caption{Quicksort}
\begin{algorithmic}
\PROCEDURE{Quicksort}{$$A, p, r$$}
    \IF{$$p < r$$}
        \STATE $$q = $$ \CALL{Partition}{$$A, p, r$$}
        \STATE \CALL{Quicksort}{$$A, p, q - 1$$}
        \STATE \CALL{Quicksort}{$$A, q + 1, r$$}
    \ENDIF
\ENDPROCEDURE
\PROCEDURE{Partition}{$$A, p, r$$}
    \STATE $$x = A[r]$$
    \STATE $$i = p - 1$$
    \FOR{$$j = p$$ \TO $$r - 1$$}
        \IF{$$A[j] < x$$}
            \STATE $$i = i + 1$$
            \STATE exchange
            $$A[i]$$ with $$A[j]$$
        \ENDIF
        \STATE exchange $$A[i]$$ with $$A[r]$$
    \ENDFOR
\ENDPROCEDURE
\end{algorithmic}
\end{algorithm}
```

Generates:

% This quicksort algorithm is extracted from Chapter 7, Introduction to Algorithms (3rd edition)
\begin{algorithm}
\caption{Quicksort}
\begin{algorithmic}
\PROCEDURE{Quicksort}{$$A, p, r$$}
    \IF{$$p < r$$}
        \STATE $$q = $$ \CALL{Partition}{$$A, p, r$$}
        \STATE \CALL{Quicksort}{$$A, p, q - 1$$}
        \STATE \CALL{Quicksort}{$$A, q + 1, r$$}
    \ENDIF
\ENDPROCEDURE
\PROCEDURE{Partition}{$$A, p, r$$}
    \STATE $$x = A[r]$$
    \STATE $$i = p - 1$$
    \FOR{$$j = p$$ \TO $$r - 1$$}
        \IF{$$A[j] < x$$}
            \STATE $$i = i + 1$$
            \STATE exchange
            $$A[i]$$ with $$A[j]$$
        \ENDIF
        \STATE exchange $$A[i]$$ with $$A[r]$$
    \ENDFOR
\ENDPROCEDURE
\end{algorithmic}
\end{algorithm}

```diff
diff --git a/sample.js b/sample.js
index 0000001..0ddf2ba
--- a/sample.js
+++ b/sample.js
@@ -1 +1 @@
-console.log("Hello World!")
+console.log("Hello from Diff2Html!")
```

Which generates:

diff --git a/sample.js b/sample.js
index 0000001..0ddf2ba
--- a/sample.js
+++ b/sample.js
@@ -1 +1 @@
-console.log("Hello World!")
+console.log("Hello from Diff2Html!")

But this is difficult to read, specially if you have a large diff. You can use diff2html to display a more readable version of the diff. For this, just use diff2html instead of diff for the code block language:

```diff2html
diff --git a/sample.js b/sample.js
index 0000001..0ddf2ba
--- a/sample.js
+++ b/sample.js
@@ -1 +1 @@
-console.log("Hello World!")
+console.log("Hello from Diff2Html!")
```

If we use a longer example, for example this commit from diff2html, it will generate the following output:

From 2aaae31cc2a37bfff83430c2c914b140bee59b6a Mon Sep 17 00:00:00 2001
From: Rodrigo Fernandes <rtfrodrigo@gmail.com>
Date: Sun, 9 Oct 2016 16:41:54 +0100
Subject: [PATCH 1/2] Initial template override support

---
 scripts/hulk.js                    |  4 ++--
 src/diff2html.js                   |  3 +--
 src/file-list-printer.js           | 11 ++++++++---
 src/hoganjs-utils.js               | 29 +++++++++++++++++------------
 src/html-printer.js                |  6 ++++++
 src/line-by-line-printer.js        |  6 +++++-
 src/side-by-side-printer.js        |  6 +++++-
 test/file-list-printer-tests.js    |  2 +-
 test/hogan-cache-tests.js          | 18 +++++++++++++++---
 test/line-by-line-tests.js         |  3 +--
 test/side-by-side-printer-tests.js |  3 +--
 11 files changed, 62 insertions(+), 29 deletions(-)

diff --git a/scripts/hulk.js b/scripts/hulk.js
index 5a793c18..a4b1a4d5 100755
--- a/scripts/hulk.js
+++ b/scripts/hulk.js
@@ -173,11 +173,11 @@ function namespace(name) {
 // write a template foreach file that matches template extension
 templates = extractFiles(options.argv.remain)
   .map(function(file) {
-    var openedFile = fs.readFileSync(file, 'utf-8');
+    var openedFile = fs.readFileSync(file, 'utf-8').trim();
     var name;
     if (!openedFile) return;
     name = namespace(path.basename(file).replace(/\..*$/, ''));
-    openedFile = removeByteOrderMark(openedFile.trim());
+    openedFile = removeByteOrderMark(openedFile);
     openedFile = wrap(file, name, openedFile);
     if (!options.outputdir) return openedFile;
     fs.writeFileSync(path.join(options.outputdir, name + '.js')
diff --git a/src/diff2html.js b/src/diff2html.js
index 21b0119e..64e138f5 100644
--- a/src/diff2html.js
+++ b/src/diff2html.js
@@ -7,7 +7,6 @@

 (function() {
   var diffParser = require('./diff-parser.js').DiffParser;
-  var fileLister = require('./file-list-printer.js').FileListPrinter;
   var htmlPrinter = require('./html-printer.js').HtmlPrinter;

   function Diff2Html() {
@@ -43,7 +42,7 @@

     var fileList = '';
     if (configOrEmpty.showFiles === true) {
-      fileList = fileLister.generateFileList(diffJson, configOrEmpty);
+      fileList = htmlPrinter.generateFileListSummary(diffJson, configOrEmpty);
     }

     var diffOutput = '';
diff --git a/src/file-list-printer.js b/src/file-list-printer.js
index e408d9b2..1e0a2c61 100644
--- a/src/file-list-printer.js
+++ b/src/file-list-printer.js
@@ -8,11 +8,16 @@
 (function() {
   var printerUtils = require('./printer-utils.js').PrinterUtils;

-  var hoganUtils = require('./hoganjs-utils.js').HoganJsUtils;
+  var hoganUtils;
+
   var baseTemplatesPath = 'file-summary';
   var iconsBaseTemplatesPath = 'icon';

-  function FileListPrinter() {
+  function FileListPrinter(config) {
+    this.config = config;
+
+    var HoganJsUtils = require('./hoganjs-utils.js').HoganJsUtils;
+    hoganUtils = new HoganJsUtils(config);
   }

   FileListPrinter.prototype.generateFileList = function(diffFiles) {
@@ -38,5 +43,5 @@
     });
   };

-  module.exports.FileListPrinter = new FileListPrinter();
+  module.exports.FileListPrinter = FileListPrinter;
 })();
diff --git a/src/hoganjs-utils.js b/src/hoganjs-utils.js
index 9949e5fa..0dda08d7 100644
--- a/src/hoganjs-utils.js
+++ b/src/hoganjs-utils.js
@@ -8,18 +8,19 @@
 (function() {
   var fs = require('fs');
   var path = require('path');
-
   var hogan = require('hogan.js');

   var hoganTemplates = require('./templates/diff2html-templates.js');

-  var templatesPath = path.resolve(__dirname, 'templates');
+  var extraTemplates;

-  function HoganJsUtils() {
+  function HoganJsUtils(configuration) {
+    this.config = configuration || {};
+    extraTemplates = this.config.templates || {};
   }

-  HoganJsUtils.prototype.render = function(namespace, view, params, configuration) {
-    var template = this.template(namespace, view, configuration);
+  HoganJsUtils.prototype.render = function(namespace, view, params) {
+    var template = this.template(namespace, view);
     if (template) {
       return template.render(params);
     }
@@ -27,17 +28,16 @@
     return null;
   };

-  HoganJsUtils.prototype.template = function(namespace, view, configuration) {
-    var config = configuration || {};
+  HoganJsUtils.prototype.template = function(namespace, view) {
     var templateKey = this._templateKey(namespace, view);

-    return this._getTemplate(templateKey, config);
+    return this._getTemplate(templateKey);
   };

-  HoganJsUtils.prototype._getTemplate = function(templateKey, config) {
+  HoganJsUtils.prototype._getTemplate = function(templateKey) {
     var template;

-    if (!config.noCache) {
+    if (!this.config.noCache) {
       template = this._readFromCache(templateKey);
     }

@@ -53,6 +53,7 @@

     try {
       if (fs.readFileSync) {
+        var templatesPath = path.resolve(__dirname, 'templates');
         var templatePath = path.join(templatesPath, templateKey);
         var templateContent = fs.readFileSync(templatePath + '.mustache', 'utf8');
         template = hogan.compile(templateContent);
@@ -66,12 +67,16 @@
   };

   HoganJsUtils.prototype._readFromCache = function(templateKey) {
-    return hoganTemplates[templateKey];
+    return extraTemplates[templateKey] || hoganTemplates[templateKey];
   };

   HoganJsUtils.prototype._templateKey = function(namespace, view) {
     return namespace + '-' + view;
   };

-  module.exports.HoganJsUtils = new HoganJsUtils();
+  HoganJsUtils.prototype.compile = function(templateStr) {
+    return hogan.compile(templateStr);
+  };
+
+  module.exports.HoganJsUtils = HoganJsUtils;
 })();
diff --git a/src/html-printer.js b/src/html-printer.js
index 585d5b66..13f83047 100644
--- a/src/html-printer.js
+++ b/src/html-printer.js
@@ -8,6 +8,7 @@
 (function() {
   var LineByLinePrinter = require('./line-by-line-printer.js').LineByLinePrinter;
   var SideBySidePrinter = require('./side-by-side-printer.js').SideBySidePrinter;
+  var FileListPrinter = require('./file-list-printer.js').FileListPrinter;

   function HtmlPrinter() {
   }
@@ -22,5 +23,10 @@
     return sideBySidePrinter.generateSideBySideJsonHtml(diffFiles);
   };

+  HtmlPrinter.prototype.generateFileListSummary = function(diffJson, config) {
+    var fileListPrinter = new FileListPrinter(config);
+    return fileListPrinter.generateFileList(diffJson);
+  };
+
   module.exports.HtmlPrinter = new HtmlPrinter();
 })();
diff --git a/src/line-by-line-printer.js b/src/line-by-line-printer.js
index b07eb53c..d230bedd 100644
--- a/src/line-by-line-printer.js
+++ b/src/line-by-line-printer.js
@@ -11,7 +11,8 @@
   var utils = require('./utils.js').Utils;
   var Rematch = require('./rematch.js').Rematch;

-  var hoganUtils = require('./hoganjs-utils.js').HoganJsUtils;
+  var hoganUtils;
+
   var genericTemplatesPath = 'generic';
   var baseTemplatesPath = 'line-by-line';
   var iconsBaseTemplatesPath = 'icon';
@@ -19,6 +20,9 @@

   function LineByLinePrinter(config) {
     this.config = config;
+
+    var HoganJsUtils = require('./hoganjs-utils.js').HoganJsUtils;
+    hoganUtils = new HoganJsUtils(config);
   }

   LineByLinePrinter.prototype.makeFileDiffHtml = function(file, diffs) {
diff --git a/src/side-by-side-printer.js b/src/side-by-side-printer.js
index bbf1dc8d..5e3033b3 100644
--- a/src/side-by-side-printer.js
+++ b/src/side-by-side-printer.js
@@ -11,7 +11,8 @@
   var utils = require('./utils.js').Utils;
   var Rematch = require('./rematch.js').Rematch;

-  var hoganUtils = require('./hoganjs-utils.js').HoganJsUtils;
+  var hoganUtils;
+
   var genericTemplatesPath = 'generic';
   var baseTemplatesPath = 'side-by-side';
   var iconsBaseTemplatesPath = 'icon';
@@ -26,6 +27,9 @@

   function SideBySidePrinter(config) {
     this.config = config;
+
+    var HoganJsUtils = require('./hoganjs-utils.js').HoganJsUtils;
+    hoganUtils = new HoganJsUtils(config);
   }

   SideBySidePrinter.prototype.makeDiffHtml = function(file, diffs) {
diff --git a/test/file-list-printer-tests.js b/test/file-list-printer-tests.js
index a502a46f..60ea3208 100644
--- a/test/file-list-printer-tests.js
+++ b/test/file-list-printer-tests.js
@@ -1,6 +1,6 @@
 var assert = require('assert');

-var fileListPrinter = require('../src/file-list-printer.js').FileListPrinter;
+var fileListPrinter = new (require('../src/file-list-printer.js').FileListPrinter)();

 describe('FileListPrinter', function() {
   describe('generateFileList', function() {
diff --git a/test/hogan-cache-tests.js b/test/hogan-cache-tests.js
index 190bf6f8..3bb754ac 100644
--- a/test/hogan-cache-tests.js
+++ b/test/hogan-cache-tests.js
@@ -1,6 +1,6 @@
 var assert = require('assert');

-var HoganJsUtils = require('../src/hoganjs-utils.js').HoganJsUtils;
+var HoganJsUtils = new (require('../src/hoganjs-utils.js').HoganJsUtils)();
 var diffParser = require('../src/diff-parser.js').DiffParser;

 describe('HoganJsUtils', function() {
@@ -21,16 +21,28 @@ describe('HoganJsUtils', function() {
       });
       assert.equal(emptyDiffHtml, result);
     });
+
     it('should render view without cache', function() {
       var result = HoganJsUtils.render('generic', 'empty-diff', {
         contentClass: 'd2h-code-line',
         diffParser: diffParser
       }, {noCache: true});
-      assert.equal(emptyDiffHtml + '\n', result);
+      assert.equal(emptyDiffHtml, result);
     });
+
     it('should return null if template is missing', function() {
-      var result = HoganJsUtils.render('generic', 'missing-template', {}, {noCache: true});
+      var hoganUtils = new (require('../src/hoganjs-utils.js').HoganJsUtils)({noCache: true});
+      var result = hoganUtils.render('generic', 'missing-template', {});
       assert.equal(null, result);
     });
+
+    it('should allow templates to be overridden', function() {
+      var emptyDiffTemplate = HoganJsUtils.compile('<p></p>');
+
+      var config = {templates: {'generic-empty-diff': emptyDiffTemplate}};
+      var hoganUtils = new (require('../src/hoganjs-utils.js').HoganJsUtils)(config);
+      var result = hoganUtils.render('generic', 'empty-diff', {myName: 'Rodrigo Fernandes'});
+      assert.equal('<p>Rodrigo Fernandes</p>', result);
+    });
   });
 });
diff --git a/test/line-by-line-tests.js b/test/line-by-line-tests.js
index 1cd92073..8869b3df 100644
--- a/test/line-by-line-tests.js
+++ b/test/line-by-line-tests.js
@@ -14,7 +14,7 @@ describe('LineByLinePrinter', function() {
         '            File without changes\n' +
         '        </div>\n' +
         '    </td>\n' +
-        '</tr>\n';
+        '</tr>';

       assert.equal(expected, fileHtml);
     });
@@ -422,7 +422,6 @@ describe('LineByLinePrinter', function() {
         '        </div>\n' +
         '    </td>\n' +
         '</tr>\n' +
-        '\n' +
         '                </tbody>\n' +
         '            </table>\n' +
         '        </div>\n' +
diff --git a/test/side-by-side-printer-tests.js b/test/side-by-side-printer-tests.js
index 76625f8e..771daaa5 100644
--- a/test/side-by-side-printer-tests.js
+++ b/test/side-by-side-printer-tests.js
@@ -14,7 +14,7 @@ describe('SideBySidePrinter', function() {
         '            File without changes\n' +
         '        </div>\n' +
         '    </td>\n' +
-        '</tr>\n';
+        '</tr>';

       assert.equal(expectedRight, fileHtml.right);
       assert.equal(expectedLeft, fileHtml.left);
@@ -324,7 +324,6 @@ describe('SideBySidePrinter', function() {
         '        </div>\n' +
         '    </td>\n' +
         '</tr>\n' +
-        '\n' +
         '                    </tbody>\n' +
         '                </table>\n' +
         '            </div>\n' +

From f3cadb96677d0eb82fc2752dc3ffbf35ca9b5bdb Mon Sep 17 00:00:00 2001
From: Rodrigo Fernandes <rtfrodrigo@gmail.com>
Date: Sat, 15 Oct 2016 13:21:22 +0100
Subject: [PATCH 2/2] Allow uncompiled templates

---
 README.md                 |  3 +++
 src/hoganjs-utils.js      |  7 +++++++
 test/hogan-cache-tests.js | 24 +++++++++++++++++++++++-
 3 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 132c8a28..46909f25 100644
--- a/README.md
+++ b/README.md
@@ -98,6 +98,9 @@ The HTML output accepts a Javascript object with configuration. Possible options
   - `synchronisedScroll`: scroll both panes in side-by-side mode: `true` or `false`, default is `false`
   - `matchWordsThreshold`: similarity threshold for word matching, default is 0.25
   - `matchingMaxComparisons`: perform at most this much comparisons for line matching a block of changes, default is `2500`
+  - `templates`: object with previously compiled templates to replace parts of the html
+  - `rawTemplates`: object with raw not compiled templates to replace parts of the html
+  > For more information regarding the possible templates look into [src/templates](https://github.com/rtfpessoa/diff2html/tree/master/src/templates)

 ## Diff2HtmlUI Helper

diff --git a/src/hoganjs-utils.js b/src/hoganjs-utils.js
index 0dda08d7..b2e9c275 100644
--- a/src/hoganjs-utils.js
+++ b/src/hoganjs-utils.js
@@ -17,6 +17,13 @@
   function HoganJsUtils(configuration) {
     this.config = configuration || {};
     extraTemplates = this.config.templates || {};
+
+    var rawTemplates = this.config.rawTemplates || {};
+    for (var templateName in rawTemplates) {
+      if (rawTemplates.hasOwnProperty(templateName)) {
+        if (!extraTemplates[templateName]) extraTemplates[templateName] = this.compile(rawTemplates[templateName]);
+      }
+    }
   }

   HoganJsUtils.prototype.render = function(namespace, view, params) {
diff --git a/test/hogan-cache-tests.js b/test/hogan-cache-tests.js
index 3bb754ac..a34839c0 100644
--- a/test/hogan-cache-tests.js
+++ b/test/hogan-cache-tests.js
@@ -36,7 +36,7 @@ describe('HoganJsUtils', function() {
       assert.equal(null, result);
     });

-    it('should allow templates to be overridden', function() {
+    it('should allow templates to be overridden with compiled templates', function() {
       var emptyDiffTemplate = HoganJsUtils.compile('<p></p>');

       var config = {templates: {'generic-empty-diff': emptyDiffTemplate}};
@@ -44,5 +44,27 @@ describe('HoganJsUtils', function() {
       var result = hoganUtils.render('generic', 'empty-diff', {myName: 'Rodrigo Fernandes'});
       assert.equal('<p>Rodrigo Fernandes</p>', result);
     });
+
+    it('should allow templates to be overridden with uncompiled templates', function() {
+      var emptyDiffTemplate = '<p></p>';
+
+      var config = {rawTemplates: {'generic-empty-diff': emptyDiffTemplate}};
+      var hoganUtils = new (require('../src/hoganjs-utils.js').HoganJsUtils)(config);
+      var result = hoganUtils.render('generic', 'empty-diff', {myName: 'Rodrigo Fernandes'});
+      assert.equal('<p>Rodrigo Fernandes</p>', result);
+    });
+
+    it('should allow templates to be overridden giving priority to compiled templates', function() {
+      var emptyDiffTemplate = HoganJsUtils.compile('<p></p>');
+      var emptyDiffTemplateUncompiled = '<p>Not used!</p>';
+
+      var config = {
+        templates: {'generic-empty-diff': emptyDiffTemplate},
+        rawTemplates: {'generic-empty-diff': emptyDiffTemplateUncompiled}
+      };
+      var hoganUtils = new (require('../src/hoganjs-utils.js').HoganJsUtils)(config);
+      var result = hoganUtils.render('generic', 'empty-diff', {myName: 'Rodrigo Fernandes'});
+      assert.equal('<p>Rodrigo Fernandes</p>', result);
+    });
   });
 });

Image Slider

This is a simple image slider. It uses the Swiper library. Check the examples page for more information of what you can achieve with it.

Image Comparison Slider

This is a simple image comparison slider. It uses the img-comparison-slider library. Check the examples page for more information of what you can achieve with it.

```vega_lite
{
  "$schema": "https://vega.github.io/schema/vega-lite/v5.json",
  "description": "A dot plot showing each movie in the database, and the difference from the average movie rating. The display is sorted by year to visualize everything in sequential order. The graph is for all Movies before 2019.",
  "data": {
    "url": "https://raw.githubusercontent.com/vega/vega/main/docs/data/movies.json"
  },
  "transform": [
    {"filter": "datum['IMDB Rating'] != null"},
    {"filter": {"timeUnit": "year", "field": "Release Date", "range": [null, 2019]}},
    {
      "joinaggregate": [{
        "op": "mean",
        "field": "IMDB Rating",
        "as": "AverageRating"
      }]
    },
    {
      "calculate": "datum['IMDB Rating'] - datum.AverageRating",
      "as": "RatingDelta"
    }
  ],
  "mark": "point",
  "encoding": {
    "x": {
      "field": "Release Date",
      "type": "temporal"
    },
    "y": {
      "field": "RatingDelta",
      "type": "quantitative",
      "title": "Rating Delta"
    },
    "color": {
      "field": "RatingDelta",
      "type": "quantitative",
      "scale": {"domainMid": 0},
      "title": "Rating Delta"
    }
  }
}
```

Which generates:

{
  "$schema": "https://vega.github.io/schema/vega-lite/v5.json",
  "description": "A dot plot showing each movie in the database, and the difference from the average movie rating. The display is sorted by year to visualize everything in sequential order. The graph is for all Movies before 2019.",
  "data": {
    "url": "https://raw.githubusercontent.com/vega/vega/main/docs/data/movies.json"
  },
  "transform": [
    {"filter": "datum['IMDB Rating'] != null"},
    {"filter": {"timeUnit": "year", "field": "Release Date", "range": [null, 2019]}},
    {
      "joinaggregate": [{
        "op": "mean",
        "field": "IMDB Rating",
        "as": "AverageRating"
      }]
    },
    {
      "calculate": "datum['IMDB Rating'] - datum.AverageRating",
      "as": "RatingDelta"
    }
  ],
  "mark": "point",
  "encoding": {
    "x": {
      "field": "Release Date",
      "type": "temporal"
    },
    "y": {
      "field": "RatingDelta",
      "type": "quantitative",
      "title": "Rating Delta"
    },
    "color": {
      "field": "RatingDelta",
      "type": "quantitative",
      "scale": {"domainMid": 0},
      "title": "Rating Delta"
    }
  }
}

This plot supports both light and dark themes.