Open-Form Geometric Style Transfer

Introduction

Style transfer is a long-standing and intriguing problem in visual computing: given examples that contain both content and style, the goal is to capture the essence of the style, separate it from the particular content on which it is observed, and apply it to new content. The separation of style from content has been studied for decades [7, 8], and has more recently become central to neural style transfer and generative modeling [13, 15, 27]. At the heart of the problem lies the ability to distinguish what is represented from how it is expressed.

In this work, we focus on geometric style, where style governs how an underlying structure is geometrically realized. A canonical example is a font: different glyphs have different structures, yet their geometric realizations follow a coherent design language that makes them immediately recognizable as belonging to the same font. More generally, such geometric styles cannot be inferred from a single example; it is revealed through a collection of different shapes that share the same design language. Early work has considered related notions of separating style from content and transferring geometric style across shapes [9, 25].

Existing approaches [22, 26, 29] typically learn and apply such styles within a shared domain: a style observed on letters is transferred to other letters, and a style observed on human figures is applied to other human figures. We remove this restriction and consider transferring a geometric style to an open space of forms. As illustrated in Figure 1, a style learned from a Latin alphabet may be applied to Greek glyphs, or more radically, to human poses; conversely, a geometric style learned from pictograms may be applied to glyphs. We call this new setting Open-Form Geometric Style Transfer, where the forms to which a learned geometric style can be applied are not restricted to the shape family in which that style was observed. We focus on forms whose underlying structure can be represented by a sparse structural sketch, which serves as the geometry to be styled.

The open-form setting, illustrated in Figure 2, is deceptively challenging. The difficulty is not simply learning a style, but learning the style without learning the shape family in which that style was observed. Existing font-generation methods can transfer styles to unseen glyphs [18, 26, 29, 32], and some explicitly separate character content from style. However, their structural component is learned and evaluated largely within the glyph domain, often within a single writing system. This distinction becomes critical when the target form leaves the source domain. A straightforward LoRA trained on a limited styled shape family learns an entangled style with the geometries observed at training (§ 4.2), causing it to drift toward familiar source-domain shapes when presented with substantially different target geometries.

Our approach addresses this entanglement by separating structural adherence from style realization. A Geometry LoRA is responsible for faithfully following the target structural sketch serving as a geometric-adherence prior, while a Style LoRA learns how that geometry should be realized in the desired style. Accordingly, the Geometry LoRA must be universal: generalize across the vast universe of styles, responding to structure rather than shape identity or residual stylistic cues. Acquiring such a universal geometry prior is itself non-trivial: a corpus of ordinary glyphs provides a limited and familiar geometry vocabulary, allowing the model to recognize known shapes rather than truly follow the input structure. We therefore introduce a geometry-enrichment strategy (GEE § 3.2) that systematically leverages SVG font data to construct a large collection of unfamiliar synthetic geometries, untangled from their source style. This strategy proves vital for successfully learning a universal geometry LoRA.

Our contributions are threefold:

• We introduce Open-Form Geometric Stylization, where a geometric style learned from one shape domain is applied to universally arbitrary forms.

• We show that open-form stylization requires separating

structural adherence from style realization.

• Finally, we introduce a geometry-enrichment strategy for constructing the broad and diverse structural training distribution needed to acquire this universal prior.

We evaluate these ideas through controlled ablations and increasingly challenging transfers, from held-out glyphs and cross-alphabet transfer to unrelated forms such as human poses, demonstrating that a geometric style can be extended well beyond the family of shapes on which it was observed.

Background and Related Work

Our work builds on three lines of research: the separation of style and content, font and glyph style transfer, and structurally conditioned generation. Below we review each line, clarify how our notion of geometric style relates to them, and how they relate to our approach.

Style and Content

Our work is closely connected to the seminal work of Tenenbaum and Freeman [25] on separating style and content. Using bilinear models, they showed that a common style can be inferred from multiple observations and applied to new content. Particularly relevant to our setting is their treatment of fonts, where style is shared across different letters and can be used to synthesize previously unseen characters. This provides an early and elegant formulation of style as a factor that can be learned across a family of shapes and separated from their individual geometry. Our work builds on this perspective, but considers an open-form setting in which the new content need not belong to the same family: a geometric style learned from one alphabet may be applied to another alphabet, or even to a different class of structures such as human poses.

More broadly, style transfer has a long history in computer vision and graphics, with much of the literature focusing on style as visual appearance. Early example-based methods [7, 8] synthesized and transferred texture by sampling local neighborhoods or patches from example images. [13] later introduced neural style transfer, demonstrating that content and artistic style can be represented separately within a deep network and recombined to render new content in the appearance of a reference image. Recent diffusion-based methods such as StyleAligned [15], B-LoRA [10], InstantStyle [28], and ZipLoRA [24] substantially extend the quality and flexibility of reference-based style transfer. Across these works, style is predominantly expressed through visual appearance, including texture, color, material, brushwork, and shading.

Our notion of geometric style is different. Here, style determines how an underlying structure is geometrically realized: how curves are formed, junctions are connected, strokes vary in thickness, gaps are introduced, and structural elements terminate or interact. Such a style is naturally revealed by a set of related shapes rather than by a single reference image. Glyphs provide a particularly clean instance of this setting: individual characters differ in structure, while together they reveal a consistent geometric design language. Related notions of transferring geometric style across shapes were also explored in early work by [9]. More recently, geometric stylization has also been explored for 3D shapes [5].

Closely related, Abstraction in Style (AiS) [19] also separates geometry from appearance using two specialized LoRA adapters. However, AiS learns style-specific geometric abstraction, whereas our Geometry LoRA is universal, enabling a learned geometric style to generalize to unseen structural sketches across shape families.

Font and Glyph Style Transfer

Modern font-generation methods provide the closest setting to our work, as they explicitly transfer a common style across glyphs with different structures. FontDiffuser [29] formulates one-shot diffusion-based font generation, using multi-scale content aggregation to preserve character structure and contrastive learning to capture style. It generalizes to unseen characters and also demonstrates cross-lingual generation. MX-Font [22] addresses few-shot font generation using multiple localized experts that disentangle content and style while capturing different local style characteristics. It also demonstrates cross-lingual generalization to unseen writing systems. VecFusion [26] approaches font generation in the vector domain, explicitly modeling glyph topology, paths, and Bézier control points, and supports applications including glyph completion and few-shot style transfer. Skeleton-Guided Diffusion [32] is particularly related to our structural representation, using character skeletons to guide diffusion and preserve structure during font generation. StrokeStyles [1] decomposes font glyphs into meaningful stroke structures and uses this representation for consistent geometric stylization across characters.

FLUX-Font [18] is particularly close to our work architecturally. It adapts a pre-trained diffusion transformer using separate LoRA modules [17] for glyph content and style, explicitly separating the two factors rather than learning them through a single adapter. Our method shares this general motivation, but separates structural adherence from style realization hierarchically: a universal Geometry LoRA is first trained to follow arbitrary structural sketches, and each Style LoRA is subsequently learned with this geometry prior active and fixed.

Despite their differences, these methods share an important restriction: their structural representations and learned priors are designed for the glyph domain. Their goal is to generalize from observed characters to other characters, possibly across writing systems, but the target remains a glyph. Open-form transfer removes this restriction. The target structural sketch may describe a character, a pictogram, a human pose, or another unrelated form. Consequently, separating content from style within the font domain is not sufficient; the geometry-following component must itself generalize beyond the shape family in which the style was observed.

Structural Conditioning

Spatially conditioned diffusion models provide a complementary line of related work. ControlNet [31] and T2I-Adapter [20] condition pre-trained text-to-image models on spatial signals such as edges, depth, segmentation, poses, and sketches, while Sketch-Guided Diffusion [27] focuses specifically on generation controlled by free-form sketches. These methods demonstrate that strong spatial adherence can be learned over broad image distributions.

Our problem, however, is not spatial conditioning alone. The structural sketch specifies a form whose geometric realization must change according to a style learned from a separate set of examples. The challenge is therefore to preserve the target structure while preventing the learned style from carrying with it the shape distribution on which that style was observed. We use structural conditioning as a means toward this goal, learning a universal geometry prior that remains fixed while different geometric styles are acquired. At inference, we treat structure and style as independent conditions and adopt the dual-conditioning guidance of InstructPix2Pix [3], allowing their strengths to be controlled separately.

Method

Given a collection of shapes sharing a geometric style, our goal is to learn that style and apply it to a new target form specified by a structural sketch. We use the term sketch-glyph for a pair consisting of a structural sketch and its styled realization. The term originates naturally from fonts, where a sketch specifies the structure of a character and the glyph realizes it in a particular font. In this work, we extend this notion to pictograms, symbols, and other structured forms that are not letters. Given a small collection of sketch-glyph pairs sharing a style, we aim to realize arbitrary new structural sketches in that style, as illustrated in Figure 2.

Figure 3 provides an overview of the method. Our key design is to separate the two responsibilities involved in this task. A Universal Geometry LoRA (UGL) provides a general ability to faithfully follow the input structural sketch, while a Style LoRA learns how the conditioned geometry should be realized in the target style. The two adapters are learned hierarchically rather than independently. UGL is trained once (Figure 3 ii); each Style LoRA is subsequently trained on top of the frozen UGL (Figure 3 iii).

For this separation to support open-form transfer, UGL itself must generalize far beyond any particular shape family. We therefore train it on a large and purposefully diverse collection of synthetic geometries constructed by our Geometry Enrichment Engine (GEE) (Figure 3 i).

At inference (Figure 3 iv), UGL and the selected Style LoRA are applied jointly. Their contributions can be controlled independently through separate geometry and style guidance scales, allowing us to balance adherence to the target structure against the strength of its stylistic realization. The following sections describe UGL, GEE, and Style LoRA training in detail.

Universal Geometry LoRA (UGL)

The purpose of UGL is to fine-tune a text-to-image diffusion model to follow open-form geometries (i.e. sketches). Starting from a pre-trained text-to-image diffusion transformer (DiT), we fit LoRA parameters on the DiT’s weights using sketch-glyph data pairs constructed by GEE. The rich, diverse synthetic data produced by the GEE allows us to select a high LoRA rank without overfitting, giving the UGL significant learning capacity. After this one-time training, we freeze UGL and share it across all Style LoRAs, providing a common geometry prior beyond each style’s specific training examples.

Geometry Enrichment Engine (GEE)

Fonts are a natural starting point for data augmentation: they are available in a large variety of styles, and more importantly, their SVG native representation enables truly geometric augmentations compared to raster form. However, using real font glyphs directly presents two limitations. First, available fonts cover a relatively narrow set of languages and therefore a limited vocabulary of structures, which may hinder generalization to unseen scripts and, even more, to out-of-domain forms such as symbols or pictograms. Second, the geometry of a glyph is itself tied to the style of its source font, so the conditioning structure may carry unwanted stylistic cues. To address both issues, we introduce GEE: a data-generation procedure that expands the range of training geometries while reducing their dependence on font style. To increase structural diversity, GEE takes advantage of the native SVG parameterization of fonts and constructs novel geometric forms by applying random sequences of geometric edits. We refer to each such sequence as a geometric recipe. A recipe may, for example, repeatedly remove or merge SVG parts, producing coherent but unfamiliar structures (Figure 4(a)). Recipes also allow the GEE to address the second problem. A recipe applied to one font can be re-applied to matching letters from another font, producing paired data with similar structure but different styles (Figure 4(b)). During UGL training, we form mixed pairs by taking the conditioning sketch from one font and the target from another font to which the same recipe was applied (Figure 4(c)). The sketch and target therefore remain aligned in structure while differing in style, encouraging UGL to learn the supplied geometry independently of its stylistic realization.

We next describe the editing primitives that drive the geometry enrichment process, first motivating their design and then outlining each one (full details in Appendix C).

Structural editing primitives. A glyph’s structure is determined by how its strokes relate: which strokes meet and where they branch or terminate. Smooth transformations such as warping, shearing, or scaling can change a glyph’s appearance, but they do not create new structural relations between its strokes. To generate genuinely new structures, we therefore need operations that modify these relations. We propose two elementary edits: component removal and merging. This builds on a broader principle: deleting and recombining existing parts can generate meaningful structural variation [11], and related cut-based augmentations have been shown to improve recognition performance [6, 30]. Repeating these edits produces novel structural relations beyond those found in existing alphabets.

To make both edits transferable across fonts, we edit the glyph’s structure rather than its contour, which is more sensitive to stylistic variation. We therefore represent each glyph as a graph, with strokes as edges and intersections and endpoints as nodes. A recipe is then expressed as a sequence of graph edits, with component removal and merging each applied one to three times. The edit type and its structural parameters are sampled when the recipe is created, specifying which component to remove or where components should connect. Because the edits are defined structurally, the same recipe can be replayed across fonts to produce the same underlying structure in multiple styles. Structural correspondence across styles is further explained in Appendix § 8.

Graph extraction. We represent each glyph as a graph that captures its dominant stroke structure (Figure 5). Starting from the glyph (a), we compute its medial axis together with the local inscribed-disk radius, which provides an estimate of stroke thickness (b). We prune short branches caused by serifs and other stylistic details, leaving the main stroke structure (c). Pixel chains are then collapsed into edges, with junctions and stroke endpoints represented as nodes (d). Finally, we classify each edge by its structural role: an edge between two junctions is a bar, while an edge from a junction to an endpoint is a leg (e).

Component removal. Figure 6 illustrates the process. Our strategy is to perform the edit in the medial-axis representation and then reconstruct the glyph back in the SVG domain. Outline points unrelated to the removed component are preserved exactly. Only the region surrounding the cut is reconstructed, where additional processing is needed to obtain a clean, style-consistent boundary. Using the graph extracted in the previous step, we locate the component to remove from its structure, which lets us find the same component across styles (a). As seen in Figure 6(b), simply removing the red branch can leave bulges where it connects to the remaining blue branches. We therefore trim these regions and reconnect the remaining blue branches. We then separate the pixels belonging to the removed region from those that should remain (c). This produces a pixel removal mask, which we convert to a smooth vector representation (d). Additional reconstruction steps are described in the appendix. The final removal result is shown in (e).

Merging. Figure 7 illustrates the process. We begin with two glyphs from the same style: a guest (a) and a host (b), and aim to combine them into a single coherent glyph. As in component removal, we perform the edit in the medial-axis representation and reconstruct the result in the SVG domain. Using the graphs extracted in the previous step, we identify where the guest should connect to the host based on their structural attributes. The process starts by randomly generating a candidate merging recipe, combining a set of simple augmentations, such as mirroring, rotation, and scaling, with a pair of connection points selected from the guest and host graphs, shown as red points in (c,d). To assess the result produced by the recipe, we apply the augmentations and connect the glyphs at the selected points. We approve only recipes that produce a clean, coherent shape (e). A merging recipe is retained only if it succeeds across a minimum number of styles. Additional implementation details are provided in the appendix. The final merging result is shown in (f).

Style LoRA

We train a separate Style LoRA on sketch-glyph pairs for each target style, as shown in Figure 3(iii). The backbone and UGL parameters remain fixed, while UGL continues to guide the geometry throughout training. Only the Style LoRA is optimized, allowing it to focus on how that geometry is realized in the target style. Here we use a low-rank adapter, far smaller than UGL: its limited capacity helps keep the style update from re-learning geometry or competing with the shared geometry prior. Following previous work [12, 23], we associate each style with a unique rare token. This token and a short appearance description provide the textual conditioning during both Style LoRA training and inference.

Geometry reinforcement. The few style examples also share a limited family of geometries, so the Style LoRA may still tie the learned style to those geometries despite UGL’s structural guidance. To preserve open-form transfer, we mix geometry-enriched sketch–glyph pairs into its training batches, shown by the connection from GEE to Style LoRA training in Figure 3. These pairs expose the model to geometries outside the target style’s examples throughout adaptation, reinforcing its ability to follow new structures while learning the style.

Inference

After training, we apply UGL and the selected Style LoRA jointly to the base diffusion model to map structural sketches to styled outputs (Figure 3 iv). To control geometry adherence and style strength separately, we adopt dual classifier-free guidance following InstructPix2Pix [3]. During training, the structural sketch, the style caption, or both are dropped to their null conditions, so a single network learns all four conditioning combinations. During sampling, we combine three forward passes using two CFG coefficients to obtain separate geometry and style guidance strengths, balancing adherence to the input sketch geometry vs. the target style. Appendix § 7 provides the guidance formulation and implementation details.

This joint application supports transfer to new forms without further training: a pictogram style can depict new human poses, while a sculptural style can turn free-form strokes into tubular shapes (Figure 1). The same sketch can also be rendered in different learned styles (Figure 2). § 4 evaluates these capabilities through qualitative and quantitative comparisons and ablations of the method’s main components.

Experiments

We evaluate our method across fonts, pictograms, and object-centric styles, using sketches of increasing structural novelty:

• In-domain, held-out test examples from the same source domain as the style training data

• Near-domain, semantically related but structurally unseen examples, such as non-Latin glyphs for fonts and everyday human poses for pictograms

• Out-of-domain, structures from unrelated shape families, such as non-glyph sketches for font styles or non-human sketches for pictogram styles.

We compare against prior methods and perform targeted ablations to assess both open-set transfer quality and the contributions of our main design choices.

Training and Evaluation Data

The training data for the universal geometry LoRA (UGL) is produced by the geometry enrichment engine (GEE) from 80 base glyphs (Latin letters, Latin Extended letters, and digits) shared across 16 fonts. Applying 6,000 random recipes yields 42,705 sketch–glyph pairs, on which UGL is trained once (Appendix § 9). Each style is represented by a small exemplar set with manually drawn structural sketches. We hold out six examples per style for evaluation and train the Style LoRA on the remainder, yielding roughly 20–70 sketch–exemplar pairs per style. During Style LoRA training, 10% of each batch is replayed from the UGL training pairs using their original style-free captions, helping preserve the learned geometry prior while adapting to style. For evaluation, we use a benchmark of 50 curated sketches per style category (fonts and pictograms). To analyze how well our method and the baselines generalize, the sketches span the in-, near-, and out-of-domain tiers defined above. We evaluate across twelve styles, and for each style all methods receive the same sketches and style references.

Open-form Geometric Generalization

We tailored our main technical contributions, the universal geometry LoRA (UGL) and the geometry enrichment engine (GEE), to open-form generalization and the challenges of fine-tuning large models.

In this section, we demonstrate the necessity of both components; later in Table 1 we also present a quantitative evaluation that supports each claim.

Method	VLM-as-a-judge↑ Fonts	VLM-as-a-judge↑ Non-Fonts	Per-style Near-domain	Per-style Out-of-domain	LPIPS↓ Fonts	LPIPS↓ Non-Fonts	SSIM↑ Fonts	SSIM↑ Non-Fonts
FontDiffuser	0.459	NA	0.469	0.433	0.425	NA	0.473	NA
MX-Font	0.597	NA	0.627	0.522	0.315	NA	0.508	NA
GPT-Image-1-mini	0.773	0.713	0.766	0.796	0.299	0.304	0.473	0.326
Gemini (Nano-Banana 2)	0.918	0.971	0.936	0.927	0.284	0.239	0.505	0.433
w/o UGL	0.670	0.840	0.862	0.803	0.249	0.174	0.460	0.485
Non-hierarchical	0.915	0.763	0.738	0.735	0.250	0.264	0.465	0.382
w/o GEE	0.609	0.746	0.822	0.730	0.218	0.204	0.518	0.406
w/o Reinforcement	0.913	0.907	0.966	0.872	0.215	0.199	0.527	0.469
Ours	0.966	0.988	0.975	0.941	0.207	0.145	0.560	0.535

We begin with the most direct alternative: avoid the UGL by fine-tuning a single low-rank adapter on the few sketch–glyph pairs available for a given style. While this formulation preserves both the target geometry and the learned style on held-out examples from the same style family, it does not generalize to out-of-domain structures. Instead, the model takes a shortcut by producing results resembling the closest training example, best seen in the bottom rows of Figure 8 (w/o UGL), where the model outputs styled examples similar to English alphabet letters rather than the desired geometry. Row w/o UGL in Table 1 quantifies this behavior.

A natural hypothesis for this phenomenon is that each geometry is observed only through a single realization in the target style, providing too little variation to disentangle the geometry and style.

An intuitive solution is to train a geometry adapter on ordinary glyphs drawn from a broad corpus of fonts, using the same training settings as UGL but without employing GEE, and then train the same Style LoRA on top of it. Unfortunately, the failure persisted, now in an even more revealing form. The UGL is even more biased towards common geometries from the train set, e.g., alphabet letters, as again seen in the bottom row of the w/o GEE section of Figure 8. These results are again supported by data in Table 1.

What is instead needed is a training distribution with fewer geometric correlations, preventing the model from capturing a specific shape identity. This is solved by our second technical contribution (GEE § 3.2). The GEE’s immense augmentation strategy forces the geometry model to rely on the supplied structure rather than recognizing a known geometry. With this enriched corpus, completing our full method, the out-of-domain score rises to 0.94 (Ours in Table 1), with a geometry factor of 0.97 and style within 3% of the ceiling, and the characteristic substitutions largely disappear.

Qualitative Evaluation

We compare against FontDiffuser [29], MX-Font [22], Gemini 3.1 (Nano-Banana 2) [14], and gpt-image-1-mini [21]. All methods receive the same target sketch and style references, except FontDiffuser, which uses a single reference. We include the general-purpose models for completeness, as they require no per-style training. Additional comparisons, including the adapter-based methods B-LoRA and ZipLoRA as well as AiS, are provided in Appendix § 6.

In the in-domain tier, we evaluate held-out sketches (Figure 9). Our method closely matches the ground truth while preserving the requested geometry and fine stylistic details. Gemini and GPT often capture the overall style but drift toward familiar poses or glyphs and lose fine font details. FontDiffuser often deviates from the input structure, while MX-Font follows it more closely but transfers the target style less faithfully.

In the near-domain tier (Figure 11), we transfer styles to related but unseen forms: non-Latin glyphs. Baselines often distort these unfamiliar inputs toward known forms or lose structural or stylistic details, while our method follows the supplied geometry and preserves the target style. The zoomed examples highlight reference motifs retained in the outputs, demonstrating transfer beyond the forms seen during style adaptation.

The out-of-domain tier (Figure 10) provides a stronger test by applying pictogram and object-centric styles to structures from unrelated shape families. Across these sketches, our method retains the characteristic shapes and appearance of each style while following the new structure, demonstrating open-form transfer beyond the source domain.

Quantitative Results

We evaluate whether our method follows the structural sketch while realizing the target style, and how well both hold as the target geometry moves away from the style’s source domain. On the in-domain tier, where paired ground truth is available, we report LPIPS for perceptual similarity to the ground truth and SSIM for agreement in local image structure. For the near- and out-of-domain tiers, where paired ground truth is unavailable, we use VLM-as-a-judge [4]. The judge separately scores structural adherence to the sketch and stylistic fidelity to the references; we report their product, normalized by the score of real examples from the corresponding style (judge setup and prompt in Appendix § 11).

Comparison and ablation. Table 1 reports judge scores by style family (Fonts, Non-Fonts) and by distance from the training domain (Near, Out), followed by LPIPS and SSIM. Our full method achieves the best results across all reported measures. In the upper block, the font generators closely follow the sketch but lack style fidelity, whereas the general-purpose models better capture the target style but drift from the input structure, as reflected in their lower Out scores. The lower block ablates our method. w/o UGL removes the UGL and trains the Style LoRA directly on the base model. Non-hierarchical trains the Style LoRA without the UGL and adds the UGL only at inference. w/o GEE trains the UGL, and applies geometry reinforcement, on original glyphs only, without GEE. w/o Reinforcement uses the GEE-trained UGL but omits geometry reinforcement during style training. Their performance shows that the importance of our design choices becomes more pronounced as the target geometry moves farther from the training domain. In particular, removing geometry reinforcement lowers the Near score from 0.975 to 0.966, but causes a substantially larger drop in the Out score, from 0.941 to 0.872. This suggests that preserving geometric adherence during style adaptation is particularly important for unfamiliar forms.

User study. We complement these measures with user preferences collected from 32 participants, who compare our result against each baseline in terms of style, struc ture, and overall preference (Appendix G). Figure 12 shows the same trend as Table 1: our results are preferred over every baseline on all three criteria, with the largest margins in style and overall preference.

Conclusions, Limitations and Future Work

We introduced Open-Form Geometric Style Transfer, where a geometric style learned from one family of shapes is applied to structures well beyond that family. We showed that learning geometric style requires separating how a shape is realized from the particular geometry on which that style is observed. However, disentanglement is necessary but not sufficient. To transfer a geometric language to unseen forms, the geometry component must itself be universal.

These findings suggest an asymmetric view of geometry and style. Geometry should be learned broadly, across a large and diverse space of structures, and can be learned once as a reusable capability. Style, in contrast, can be learned from a much narrower collection of examples and specialized independently. Our Universal Geometry LoRA and Style LoRA instantiate this separation, while GEE provides the geometric diversity needed to make the former universal.

As with many fine-tuned generative models, some challenges remain. Complex structures can expose a tradeoff between geometric and stylistic fidelity, while strong or recurring stylistic elements can occasionally interfere with the target structure or become overemphasized. Improving this separation, particularly for increasingly complex geometries and styles, is an interesting direction for future work. We believe this principle may extend beyond geometric style transfer, enabling learned visual languages to be applied outside the domains in which they were observed.

Further Comparisons

§ 4 compares against font-generation models and general-purpose image generators. Here we include additional comparisons with three recent methods that are particularly relevant to our setting. B-LoRA [10] and ZipLoRA [24], like ours, use low-rank adapters to separate what is depicted from how it is rendered, while Abstraction in Style (AiS) [19] explicitly models structural abstraction as part of stylization. Figure 13 shows the B-LoRA and ZipLoRA results next to ours for the same sketch and style; AiS is discussed separately below.

B-LoRA. B-LoRA leverages LoRA to implicitly separate the style and content of a single image by jointly learning the LoRA weights of two specific SDXL blocks, which can then be used as independent components. We use the official implementation and settings, which we verified by reproducing the authors’ published example. The content adapter is trained on the structural sketch and the style adapter on six training examples of the style, matching the other reference-based baselines. As Figure 13 (left) shows, the style block carries only the palette and texture of the style: the geometric style is lost, and the structure of the sketch is replaced by hallucinated, unrelated content, because a thin line drawing provides little reconstruction signal.

ZipLoRA. ZipLoRA merges independently trained style and subject LoRAs by learning per-column merger coefficients that minimize their interference. As no official implementation exists, we implement it on our own backbone, which isolates the merging strategy: the content adapter is our UGL and the style adapter is a Style LoRA trained without the UGL, as in the Non-hierarchical ablation (§ 4.4). Both adapters are frozen and only the coefficients are optimized, with the paper’s hyperparameters. With all coefficients at one, the two adapters are simply added, which is exactly the Non-hierarchical configuration of our ablation study; sampling uses its sketches, prompts, seeds and guidance. The learned coefficients scale down both adapters, averaging 0.39-0.48 for the UGL and 0.24-0.52 for the Style LoRA across the three styles. As Figure 13 (right) shows, the result follows the sketch, but the conflict between structure and style remains, only in a milder form: style-specific details such as the pictogram tile and the wedge-shaped terminals of the display font are weakened. Training the Style LoRA with the UGL active, as we do, avoids the conflict altogether.

Abstraction in Style (AiS). AiS is designed specifically for styles in which abstraction extends beyond color and texture to geometric and structural deformation. AiS explicitly separates structural abstraction from visual stylization in two stages: it first transforms the target into an intermediate abstraction proxy that reflects the structural tendencies of the reference style, and then renders this proxy into the final stylized output. Both stages are learned from a small set of visual exemplars through its Visual Analogy Transfer framework. This makes AiS particularly relevant to our setting, as it is one of the few recent methods that explicitly treats structural reinterpretation as part of style transfer.

Figure 14 compares AiS with our method on three styles: two pictogram sets and a sculptural style. We train AiS on the same style references and use the structural sketch as the abstraction target. AiS captures the visual appearance of each style, but on the pictogram styles its outputs do not reliably follow the sketch: across the scripts, strokes are rearranged, omitted, or fused, while the runner pose is only loosely preserved. On the sculptural style, whose exemplars are themselves single continuous strokes, AiS follows the sketch more closely, though it renders every glyph as one uniform tube. This reflects AiS’s design: its abstraction proxy follows structural tendencies learned from the references rather than the geometry of a specific target. Our method follows each sketch closely while preserving the same style traits, including the tile deformation and stroke bands of the orange set.

Dual Classifier-Free Guidance

Our generator is conditioned on two inputs: a sketch image $c_I$ of the target geometry and a text caption $c_T$ that carries the style token. Conventional text-conditioned classifier-free guidance (CFG) [16] has a single scale: it amplifies the caption, while the sketch enters both branches as an ordinary, unamplified condition, so the strength of the geometric conditioning cannot be controlled. We therefore adopt the compositional guidance of InstructPix2Pix [3], which separates the two conditions into terms with independent scales.

Null conditions. CFG requires the network to model the unconditional branches, so during training each sample is assigned to one of the four conditioning branches listed in Table 2: most samples keep both conditions, one in five drops the style caption, and a small share drops the sketch or both. The image null $\varnothing_I$ is the complete absence of reference tokens, i.e. the model’s native text-to-image mode, rather than a blank or noise image, and the text null $\varnothing_T$ is the empty prompt.

Branch	% of samples	Geometry $c_I$	Style $c_T$
Fully cond.	70%	$c_I$	$c_T$
Geometry cond.	20%	$c_I$	$\varnothing_T$
Style cond.	5%	$\varnothing_I$	$c_T$
Uncond.	5%	$\varnothing_I$	$\varnothing_T$

Guidance. Let $v_\theta(z_t,c_I,c_T)$ denote the predicted velocity at noise level $t$. Each sampling step evaluates the unconditional, geometry-conditioned, and fully conditioned

branches of Table 2 (the style-only branch is not used at sampling) and combines them as

The first bracket moves the prediction toward the sketch and is scaled by the geometry scale $s_I$; the second adds the contribution of the style token on top of the sketch and is scaled by the style scale $s_T$. With $s_I=s_T$, the two brackets merge into one and the rule becomes single-scale CFG on the joint condition $(c_I,c_T)$. Values of $s_I$ above 1 amplify the geometric conditioning independently of the style scale. In practice we use $s_I \in[4,6]$ and $s_T \in[2,3]$ (§ 4).

Reading the two levers. Figure 15 jointly sweeps the two guidance scales for a held-out sketch of a “3”. The grid makes the roles of the two guidance signals and their characteristic failure modes clear.

With no sketch guidance ($s_I=0$, top row), the sketch is effectively ignored: increasing $s_T$ strengthens the style but does not recover the geometry of a “3”. At $s_I = 1$, a coherent letterform emerges, but with incorrect geometry, and strong style guidance can further distort its shape. At the other extreme, strong sketch guidance ($s_I = 8$, bottom row) reliably preserves the geometry but weakens the appearance signal. Increasing $s_T$ restores the red tubular style, though gradients and translucency remain muted. The intermediate regime ($s_I = 6$, third row) provides the best balance, recovering the correct “3” while preserving the inflated volume and warm gradient of the exemplars. We therefore choose our operating point in this regime.

Geometry Enrichment Engine: Details

This appendix details the construction of the geometry-enriched training corpus used to train UGL (§ 3.2).

Generating unfamiliar geometries. We begin with 80 base glyphs (Latin letters, Latin Extended letters, and digits) shared across 16 fonts and treat them as raw geometric material. We expand this initial vocabulary using two simple structural operations: component removal, which removes a structural part of a glyph, and merging, which combines components from two glyphs. The operations are applied iteratively, allowing newly generated shapes to participate in subsequent operations. As illustrated in Figure 4 of § 3.2, the resulting forms quickly depart from recognizable characters, producing a much broader distribution of coherent but unfamiliar geometries.

We represent each sequence of structural operations as a geometric recipe. Importantly, a recipe is defined independently of a particular font and can therefore be applied to corresponding glyphs across multiple fonts. This produces related geometric constructions realized in different styles. Beyond increasing geometric diversity, this correspondence is what allows us to separate the structural information conveyed by a sketch from the style of its target realization.

A GEE recipe is a sequence of component-removal and merging operations, with both operations applied one to three times. The output of one step is the input of the next. Both operations share a first step, graph extraction, described next.

Graph extraction. Editing a glyph’s outline directly is fragile, since a removal or a join depends on local contour details that differ from style to style. Both operators therefore act on the glyph’s underlying stroke structure, which we extract as a graph; Figure 5 of § 3.2 illustrates the steps. Starting from the glyph (a), we compute its medial axis transform, which gives the centerline of every stroke together with the radius of the maximal inscribed disk at each point, a local estimate of stroke thickness (b). Treating the axis pixels as a graph, we prune the short branches caused by serifs and other stylistic contour details, retaining the dominant stroke structure (c). Chains of pixels between meeting points are then collapsed into single edges, junctions become nodes and stroke ends become tips (d). Finally, each edge is classified (e). An edge between two junctions is a bar, and an edge from a junction to a tip is a leg. Because these roles do not depend on the exact contour of a style, an operation on these graphs can be replayed across styles.

Structural correspondence. A recipe names the component it edits, but only within the style on which it was defined. To apply the same edit consistently across styles, we must identify the corresponding component in each style. We represent the selected component using a compact descriptor consisting of its type (bar or leg), the orientation of the chord connecting its endpoints, its midpoint normalized by the glyph’s bounding box, and its arc length relative to glyph size. For each other style, we compare this descriptor with all removable components of the same type and select the component with the smallest weighted distance, provided that the distance is below a matching tolerance. If no component falls below this tolerance, the recipe is not applied to that style. A recipe is retained only if at least a minimum number of styles remain (we configured as 6).

Component removal. Figure 6 of § 3.2 illustrates the process step by step. Given the extracted graph, we aim to remove exactly one structural component, such as a leg or bar, while keeping the rest of the outline unchanged and reconstructing the cut in the font’s own terminal style (a). The component to be removed is described by its structural attributes in the graph. In each style, we use these attributes to identify the corresponding component, so that the same component is removed consistently across styles. Removing only the skeleton associated with the component’s edge is not sufficient, since part of its medial axis may also belong to the junction. To avoid leaving an artificial bulge, we remove medial-axis points near the junction within a radius slightly smaller than its inscribed-disk radius (b). This creates a small gap, which we reconnect with a straight stroke that smoothly bridges the surviving branches. We remove pixels belonging to the deleted limb while preserving those shared with surviving strokes. We then fill small junction concavities using the convex hull of the surviving strokes (c). The removal is defined as a pixel mask, but the output must be vectorized. We therefore trace the removal region into a smooth contour and subtract it from the original glyph outline (d). Geometry outside the edited region is preserved exactly. The newly exposed cut boundary has no counterpart in the original glyph. To reconstruct it in a style-consistent way, we search other glyphs from the same font for a matching outline segment, after normalizing for position, scale, and rotation. We then fit this donor segment to the exposed boundary and insert it into the cut region. The result is a glyph with one structural component removed while preserving the original outline wherever possible (e).

Merging. Figure 7 of § 3.2 illustrates the process. The connection between the two glyphs is described through structural attributes of their graphs. These attributes identify where the guest should attach to the host and allow the corresponding connection to be found across styles. We begin with two glyphs from the same style: a guest $g_a$ (a) and a host $g_b$ (b). Our goal is to attach the guest to the host so that they form a single coherent glyph. The merge has two stages. First, we augment the pair,

to generate multiple candidate configurations. The host may be mirrored, while the guest may be also rotated and scaled. These choices are randomly sampled when the recipe is created. In Figure 7(c), for example, the host is unchanged while the guest is mirrored and rotated by $270^\circ$. We then merge the augmented pair,

On the guest, the connection is anchored at a stroke end facing the host, marked by the red dot in Figure 7(c). On the host, we select the stroke end facing the guest; if none exists, we use the nearest skeleton point (Figure 7(d)). The guest is then translated so that the two connection points align. We keep only merges that form a coherent single shape, with a localized overlap at the junction and no narrow gaps or small enclosed holes, as shown in Figure 7(e). A merge recipe is retained only if it succeeds across a minimum number of styles, ensuring that the structural relation transfers consistently. Small fragments extending beyond the seam are removed to produce the final glyph, as shown in Figure 7(f).

Style-suppressed structural sketches. For each generated glyph, we extract a structural sketch from its medial axis. A raw medial axis, however, can retain local characteristics of the font from which it was extracted, allowing the conditioning sketch to inadvertently reveal style. We therefore simplify the extracted structure by pruning small branches associated with local stylistic details and approximating the remaining structure with a limited set of Bézier curves. During training, we additionally apply random modifications to these curves. Together, these operations preserve the dominant structure while making residual stylistic cues unreliable.

We now describe the style-suppressing operations in more detail.

Pruning. We first remove branches that are more likely to arise from outline decoration than from genuine stroke structure. Pruning is defined relative to the local stroke width rather than by an absolute length threshold. In an initial pass, branches shorter than 0.4 stroke widths are removed. This suppresses small decorative spurs without systematically eliminating genuinely short structural components. Serifs require separate treatment. At a serif terminal, the medial axis often splits into two short branches on opposite sides of the stroke. Removing either branch independently would shorten the stroke rather than remove only its decoration. We distinguish such serif pairs from genuine bifurcations using the line segment joining the two branch tips. If this segment lies entirely inside the glyph, the branches are treated as the two prongs of a serif. If it exits the glyph, as between the upper arms of a Y, the branches are treated as genuine structure and retained. A detected serif pair is replaced by a single branch between the two prongs, preserving the full stroke extent while discarding the terminal shape. In our fonts, serif branches span at most approximately one stroke width, whereas genuine structural limbs typically span two to five stroke widths. We therefore merge a pair only when both branches are shorter than 1.5 stroke widths. A final pruning pass removes branches shorter than 0.9 stroke widths, except where such a branch independently captures a substantial part of the glyph structure.

Representational bottleneck. We next approximate the pruned medial axis with a limited number of cubic Bézier curves. This sparse representation acts as an explicit information bottleneck rather than merely a compact encoding. A limited number of smooth curves can preserve the coarse glyph geometry, including stroke paths, curvature, and connectivity, while lacking the capacity to reproduce fine stylistic irregularities inherited from the original outline. Curve fitting is performed adaptively. The axis is initially represented by a single cubic Bézier curve and is subdivided at the point of maximum fitting error only when needed. Capacity is therefore allocated preferentially to regions that require additional geometric detail. Across our data, a glyph is represented by approximately ten curves on average and by at most 12. If this capacity is exceeded, the least significant cues are discarded as intended. The subdivision tolerance is expressed relative to stroke thickness. Because the medial axis is defined by its distance to the glyph boundary, constraining the fitting error in this way keeps the approximation geometrically consistent with the glyph interior. The resulting representation is deliberately lossy while remaining faithful to the underlying stroke geometry.

Although pruning and curve compression remove much of the stylistic information, they cannot guarantee complete invariance. A sufficiently expressive model may still exploit residual correlations between the conditioning sketch and the target style. We therefore introduce two training-time mechanisms in UGL to make such residual information unreliable.

Perturbation during training. During training, each conditioning stroke is randomly perturbed while the corresponding target glyph remains unchanged. The model therefore does not observe a single exact skeleton as the unique conditioning representation of a target. Large-scale structure is preserved, while small local details become unreliable as predictive features. The curve representation allows us to perturb strokes structurally rather than at the pixel level. We deform the interior of each curve while keeping its endpoints fixed, preserving junctions and overall connectivity. Perturbation magnitude is scaled by curve length and correlated along the stroke, causing the stroke to bend smoothly as a whole rather than introducing high-frequency local noise. Each interior control point is displaced by a Gaussian whose standard deviation is a fraction of the curve’s chord length, capped at twice that deviation so that a curve cannot fold back on itself. We resample this fraction uniformly for every sample at every epoch, from [0.10, 0.20] when training UGL and from [0.03, 0.08] when training a Style LoRA (Table 3), so the model sees a range of sketch precision rather than one fixed noise level.

	UGL (stage 1)	Style LoRA (stage 2)
LoRA rank / $\alpha$	192 / 192	32 / 32
Optimisation steps	6,000	2,500
Batch $\times$ grad. accum.	16 $\times$ 4	4 $\times$ 2
Warm-up steps	400	50
Learning rate	$10^{-4}$	$10^{-4}$
Held out	5% recipes	6 rows per style
UGL replay in batch	–	10%
Sketch perturbation	10–20%	3–8%
Hardware	1$\times$ H100	1$\times$ L40S

Cross-style pairing. To further prevent the sketch from serving as a style condition, we exploit the cross-font correspondence provided by the geometric recipes. Rather than always pairing a target glyph with its own extracted sketch, we can condition it on a sketch extracted from another font generated by the same recipe. Although their precise medial axes may differ, the sketch and target share the same underlying construction while belonging to different styles. This cross-style pairing discourages UGL from using the conditioning sketch to infer the target style.

Together, geometry enrichment, style suppression, and cross-style pairing produce a broad training distribution in which structural sketches primarily communicate geometry rather than shape identity or style. Training UGL on this corpus encourages it to follow the supplied structure, providing the universal geometry prior required for open-form transfer.

Training details

Both adapters are LoRA modules [17] on the attention projections of the FLUX.2-klein-base-4B transformer [2] (80 linear layers); the backbone, the VAE and the Qwen3 text encoder stay frozen, the text encoder in 8-bit. UGL uses rank 192 with $\alpha= 192$; every Style LoRA uses rank 32 with $\alpha= 32$ and is trained with UGL attached as a frozen adapter, never merged. Both stages use AdamW-8bit (learning rate $10^{-4}$, constant after a linear warm-up, $\beta= (0.9, 0.999)$, weight decay 0.01, $\epsilon= 10^{-6}$), an EMA of the adapter weights with decay 0.99, gradient checkpointing, and a flow-matching objective at $256 \times256$ for both the target and the sketch condition. Adapter weights are stored in fp16. Table 3 lists the per-stage settings.

Additional Results

VLM-as-a-Judge Evaluation

We employ a VLM-as-a-Judge evaluation framework to assess generated results in the open-set regimes, where no unique paired ground truth exists: for a target structure outside the style’s own shape family there is no single correct rendering to compare against, so paired metrics such as LPIPS and SSIM are undefined. The judge is asked instead whether the requested structure is depicted and whether it is realized in the demonstrated geometric design language.

Each judged candidate is presented as a single composite image with labeled panels: a top row of $K = 6$ style references, and a bottom row holding the target structural sketch and the candidate. References are drawn only from the style’s training rows, so the judge never sees the ground-truth target of the case it is grading. All panels are rendered at $256 \times256$ on a common canvas, and nothing in the image or the prompt identifies the method that produced the candidate.

We score each candidate absolutely rather than in pairs. This has two consequences we rely on: the resulting scalar does not depend on which baselines happen to be included in the comparison, and there is no left–right position bias to mitigate. To remove the remaining ordering effect, the six style references are shuffled per case with a fixed per-case permutation. The judge is instructed to return a single JSON object conforming to a strict response schema, which prevents the answer from drifting into prose and bounds the output length.

The response to the example query illustrates the two axes being scored independently. Geometry is 4 rather than 5 because the judge locates two nameable departures from the sketch before scoring it: the rider is given the head the sketch leaves implicit, and the bicycle frame is redrawn cleaner than the tangle of strokes it was traced from. Style is 4 because the candidate carries the references’ badge, weight and figure convention onto a sport none of them shows, while stopping short of being mistaken for one of

VLM-as-a-Judge: Evaluation Prompt (abridged)

System prompt: meticulous visual judge for a geometric style transfer benchmark; sees one composite image with labeled panels; answers only in schema-conforming JSON.

User prompt:

Image layout. Top row: 6 Style References, defining how things are drawn (strokes, curvature, corners, joins, color, texture, motifs). Bottom row: the Target Sketch, defining what must be depicted, and the Candidate.

Questions, answered in order:

1. geometry_deviations: list every structural difference from the sketch, each tagged core (element missing, added, moved or re-connected) or minor (element slightly shifted or reshaped).

2. geometry_score (1–5): is the sketch’s structure depicted? Deviations the references explain as style are allowed; style is not judged here. 5 = fully recognizable . . . 1 = a different object.

3. style_score (1–5): does the candidate belong to the references’ visual family? Depicting the same objects is not rewarded; geometry is not judged here. 5 = could pass as a reference . . . 3 = several traits missing . . . 1 = no resemblance.

4. flags: source_leakage, the candidate reproduces a shown reference instead of the sketch; sketch_copy, the sketch passed through with little or no style.

Output: one JSON object, {"geometry_deviations": [{"what", "severity"}], "geometry_score", "style_score", "source_leakage", "sketch_copy"}.

VLM-as-a-Judge: Example Query

Image input: one composite, sent alongside the prompt above. Here the style is a pictogram set and the requested structure is a cyclist: none of the six references depicts cycling, so the judge must separate the design language — white circle, dark badge, uniform stroke — from the particular sports that carry it.

Response:

{"geometry_deviations": [{"what": "added head", "severity": "core"}, {"what": "modified frame", "severity": "minor"}], "geometry_score": 4, "style_score": 4, "source_leakage": false, "sketch_copy": false}. them. Both flags are false: the candidate reproduces no shown reference, and it is not the sketch passed through unstyled.

Judge Configuration

We use the same judge configuration for the entire evaluation: all reported numbers come from gemini-3.1-pro-preview with a structured response schema and medium media resolution. Each candidate is judged in a single pass. Scores are aggregated hierarchically, matching the rest of our protocol: samples within a case, cases within a style, then styles weighted equally.

User Study

User Study Setup

We complement the VLM-as-a-Judge evaluation with a human preference study. Unlike the judge, which scores each candidate absolutely, the study is pairwise: participants see two results for the same input and indicate which one is better. Relative judgments are easier for non-expert participants to make consistently than absolute ratings, and they directly answer the question of interest, namely whether our results are preferred over those of each baseline.

Each question is presented as a single composite image with labeled panels: a top row with the style references and the structural sketch, and a bottom row with two results, A and B. One result is ours and the other is produced by a baseline, both generated for the same style and the same sketch. All panels, including the two results, are rendered at the same size on a common canvas, so that the native output resolution of a method is not revealed, and nothing in the image or the text identifies the method behind a result.

The study contains 12 questions: three for each of the four baselines (MX-Font, FontDiffuser, Gemini, and GPT-Image), each on a different style, covering black-and-white fonts, decorative fonts, and pictogram styles. The sketches span held-out glyphs, non-Latin glyphs, human poses, and symbols. For each question, participants answer three multiple-choice items, on style, structure, and overall preference, each with the options Result A, Result B, and About the same.

To control for ordering and position effects, we prepare four editions of the questionnaire. Each edition shuffles the order of the questions, never placing the same baseline in two consecutive questions, and randomizes which side shows our result. Within every edition our result appears as A in exactly half of the questions, and the side assignment is mirrored between editions, so that any preference for a side cancels out. Participants reach the study through a single link that assigns them to one of the editions at random. Responses are anonymous, and each participant answers one edition.

The example illustrates why the two axes are asked separately. Both results depict a recognizable treble clef, so the structure item mainly asks whether the particular structure of the sketch is preserved, such as its proportions, the spiral around the stem, and the hooked tail. The style item asks something different: whether the result carries the distinctive traits of the references, such as the rounded, asymmetric blue tile, the bold white strokes with rounded ends, and the thin parallel lines that accompany the figures, rather than merely sharing their colors.

Before the first question, participants are shown one worked example in the same layout, with the intended answers marked and a one-line explanation of each. Its two results are not method outputs: one is a letter of a reference font and the other is the same letter in a plain serif font, so the intended answers are unambiguous and do not bias participants toward any method.

Aggregation

For each baseline and each of the three items, we report the percentage of votes that prefer our result, prefer the baseline’s result, or rate the two as about the same, pooled over participants, editions, and the three questions of that baseline. Significance is assessed with a two-sided exact binomial test against 50% on the decisive votes, i.e., after discarding About the same answers. In total, 32 participants completed the study.