Windfoil: Closed-Form Coverage for Real-Time and Differentiable Vector Graphics

Abstract: We present Windfoil, a GPU-friendly algorithm that treats rasterisation and differentiable vector graphics as two sides of the same problem by evaluating the box-filtered winding number of quadratic Bézier contours in closed form. We implement this in WebGPU, allowing it to run across a range of environments, including a web browser on a consumer laptop, and apply the system to real-time 2D rendering, high-resolution rasterisation for print media, and a differentiable renderer. We compare our renderer against Skia, a production-grade engine, and Slug, a popular GPU rasterisation algorithm for games and real-time applications, measuring fidelity to a reference box-filtered coverage. Our renderer matches the reference more closely than either, at performance comparable to Slug. We also compare our optimiser against DiffVG and Bézier Splatting, where it reaches equivalent or better reconstruction quality at a fraction of the per-step cost, scaling to tens of thousands of shapes at interactive rates.

• The paper proposes a closed-form boundary-integral formulation providing an exact, per-pixel evaluation to eliminate coverage discrepancies between optimisation and final display rendering for quadratic Bézier contours without the need for sampling, distance-field textures, or curve flattening
• Windfoil distinguishes itself through a new implementation , providing seamless and differentiable WISBF, offers around a $9-13x$ lower mean errors relative to the supersampled box-filter reference compared to competitors.
• To ensure speed, the method involves an edge-efficient computation strategy using single-axis organisation and precomputed banded ink profiles. The final Webboard optimiser offers a practical speed up, with observations on the simulated mini world highlighting a possible 0.53-4.86 db improvement for the Windfoil system over Bézier Splatting, often while using 196 times less time.

Problem formulation and contribution

“Windfoil: Closed-Form Coverage for Real-Time and Differentiable Vector Graphics” (2610.02468) addresses a shared weakness in GPU vector rasterisation and differentiable vector graphics: the renderer used during optimisation often implements a different coverage model from the renderer used for final display. This discrepancy can make gradients optimise an image that is not faithfully reproduced after export. The paper proposes a single analytic formulation for both tasks: per-pixel evaluation of the box-filtered winding number of closed quadratic Bézier contours.

The central claim is that analytic antialiasing and differentiable rendering need not rely on multisampling, distance-field textures, Monte Carlo integration, or curve flattening. Instead, Windfoil integrates winding contributions over a rectangular pixel footprint in closed form. The same evaluation is implemented in WebGPU for fragment-shader rasterisation and compute-shader differentiation, with support for browser, Node.js, and Deno environments.

The paper makes four principal contributions:

• a closed-form boundary-integral formulation for quadratic Bézier contours;
• a WebGPU rasteriser and differentiable renderer based on that formulation;
• separate acceleration structures for display and optimisation; and
• empirical comparisons against Skia, Slug, DiffVG, and Bézier Splatting.

The scope is deliberately restricted. The method operates on closed quadratic contours and does not directly support cubic Bézier curves, stroked paths, clipping masks, gradients, or texture-based paint effects in the differentiable backend.

Closed-form box-filtered winding

A pointwise winding test produces a binary inside/outside classification and is therefore unsuitable for smooth antialiasing when evaluated only at pixel centres. Windfoil instead integrates the winding number over a rectangular footprint corresponding to a pixel. The filter width can be increased to produce a broader box blur, while the ordinary one-pixel footprint produces the default antialiased image.

The implementation integrates the winding function before applying the fill rule. For nonzero filling, the absolute filtered winding is clamped to one; for even-odd filling, the filtered value is mapped to its distance from the nearest even integer. This ordering is computationally convenient because curve contributions can be summed independently, but it is not equivalent to applying the fill rule at every point and then filtering the resulting binary coverage.

That distinction is important. The two procedures agree for ordinary isolated boundaries, where winding varies by at most one across the footprint. They can disagree when a pixel spans self-intersections, overlapping contours, or multiple even-odd transitions. Consequently, the paper’s “exact” claim applies to the closed-form integral of the winding field for well-formed configurations, not universally to exact filtered filled-region coverage.

The principal derivation uses Green’s theorem to convert the area integral into a boundary integral. For each horizontal strip through a pixel footprint, a curve crossing contributes a signed width determined by its position relative to the footprint’s left and right boundaries. Quadratic Bézier segments are subdivided at their extrema into at most three pieces that are monotone in both coordinates. Each piece can then be clipped vertically, intersected with the footprint boundaries by solving quadratic equations, and integrated as a polynomial. Contributions fully outside the footprint vanish or reduce to a constant-width term; the interior portion has a closed-form integral.

The result is a per-pixel evaluation that avoids sampling while retaining continuous, piecewise-differentiable dependence on control points, opacity, colour, and filter width.

GPU implementation

Windfoil uses distinct execution strategies for display and differentiation. For real-time rasterisation, shapes are rendered as instanced quads, with curve data shared across repeated instances such as text glyphs. Quadratic segments are placed into horizontal row bands. A fragment shader examines only bands intersecting its pixel footprint, and optional right-to-left sorting permits early termination when remaining segments lie outside the footprint.

This single-axis organisation is a significant implementation choice. Because the coverage integral sweeps horizontally, horizontal row bands contain the information required by a fragment. Slug, by contrast, uses horizontal and vertical ray structures. Windfoil therefore reduces storage and can inspect fewer segments in some regimes, particularly under magnification.

Minification presents the opposite problem: a small shape can occupy only a few device pixels while its footprint intersects many curves. Windfoil addresses this with a precomputed banded ink profile once the shape’s bounding box falls below approximately four pixels in width and height. This profile is an approximation rather than the closed-form per-pixel path evaluation, so the strongest accuracy measurements disable the minification guard.

The differentiable backend uses tiled shape lists constructed in painter’s order. The forward compute pass evaluates coverage and compositing for each pixel, while the backward pass recomputes the relevant forward quantities and propagates an analytic vector-Jacobian product through compositing, opacity, the fill rule, and the winding integral. Curve-level derivatives are mapped back to the original quadratic control points.

A practical limitation is that curve preprocessing remains CPU-based. In the display backend this preprocessing can be amortised across frames, but the differentiable backend must repeat it after geometry updates. The paper identifies GPU preprocessing as an unimplemented optimisation.

Rasterisation fidelity

Windfoil is evaluated against a supersampled box-filter reference generated from the original curves. The comparison includes Skia and a WebGPU implementation of Slug. Across the reported corpus, Windfoil achieves a mean absolute coverage error of $1.2 \times 10^{-4}$, compared with $1.1 \times 10^{-3}$ for Slug and $1.6 \times 10^{-3}$ for Skia. Thus, relative to this particular box-filter reference, Windfoil’s error is approximately nine times lower than Slug’s and thirteen times lower than Skia’s.

These numbers should not be interpreted as a universal ranking of production rasterisers. Skia is not designed to reproduce Windfoil’s specific filtered-winding model in every case, and the supersampled reference itself has sampling error. The result establishes that Windfoil closely approximates the selected reference model, not that it is always perceptually or geometrically preferable.

Figure 1: Coverage differences for a glyph and a self-intersecting rosette; Windfoil closely matches ordinary box-filtered edges but exhibits a seam error at a winding-cancellation self-crossing.

The qualitative comparison exposes the method’s principal failure mode. On the rosette, averaging winding before applying the fill rule causes a self-crossing seam to cancel into an apparent hole. Skia and Figma preserve the filled seam, whereas Slug exhibits a similar failure. This is a direct consequence of the paper’s approximation, rather than an implementation defect. The error is spatially confined to footprints intersecting conflicting winding regions, but such regions can be visually salient.

Windfoil also supports tent and cubic B-spline filters through quadrature over the box-filtered evaluator. These extensions reduce moiré and shimmering in dense line work, as illustrated by the sunburst experiment.

Figure 2: A 256-stroke sunburst rendered with box, tent, and cubic B-spline filtering alongside production renderers.

The broader-filter demonstrations are useful, but they do not have the same mathematical status as the box filter. The box-filtered winding integral is closed form; tent and cubic filtering use fixed-tap quadrature and therefore introduce an additional approximation and performance cost.

Rendering performance

The performance evaluation compares Windfoil with Slug over text-heavy scenes, the Ghostscript tiger, and a synthetic self-intersecting stress shape. Windfoil is not uniformly faster. Under magnification it is reported to be $1.2$–$2.6\times$ faster than Slug because a single horizontal band is sufficient. Under strong minification, the precomputed ink profile provides a reported $5$–$6\times$ speedup. In the intermediate zoom regime, however, Slug leads by $1.2$–$2.8\times$, depending on scene and zoom.

Both systems remain within a 60-fps frame budget on an Apple M2 MacBook Air for common workloads involving thousands of visible text or icon glyphs. The relevant claim is therefore competitive real-time performance across zoom regimes, rather than strict dominance over Slug.

The architecture also supports tiled high-resolution export. Since each pixel is evaluated independently, large images can be rendered in tiles without inter-tile state or boundary artefacts. The paper reports tests up to $30{,}000 \times 30{,}000$ pixels. This capability follows directly from the independent per-pixel formulation, although the reported maximum is an implementation test rather than a scalability law.

Differentiable rendering and image fitting

Windfoil’s differentiable renderer optimises quadratic closed shapes against pixelwise mean-squared error. The renderer and optimiser use the same one-pixel box-filtered coverage model, avoiding the common situation in which optimisation uses one rasterisation approximation and final rendering uses another.

The experiments compare Windfoil with DiffVG and Bézier Splatting on the Kodak image set and the Färlev photograph. The comparison is not fully symmetric: Windfoil and DiffVG share initial geometry, colours, and opacities, while Bézier Splatting uses its native representation and initialisation. DiffVG optimises at $1.1 \times 10^{-3}$0 samples per pixel but is scored using an $1.1 \times 10^{-3}$1 render; Windfoil and Bézier Splatting use their respective native procedures. Timings exclude setup, warm-up, final rendering, scoring, and output.

Benchmark	Windfoil	DiffVG	Bézier Splatting
Kodak, 512 shapes, 800 steps	26.60 dB	26.41 dB	22.80 dB
Färlev, 512 shapes, 800 steps	21.83 dB	21.79 dB	20.73 dB
Färlev, 4,096 shapes, 800 steps	26.77 dB	21.31 dB	22.61 dB
Färlev, high resolution, 256 shapes, 60 s	20.96 dB	19.96 dB	19.77 dB

The most substantial result occurs at higher shape count. At $1.1 \times 10^{-3}$2 resolution with 4,096 shapes and 800 optimisation steps, Windfoil reaches $1.1 \times 10^{-3}$3 dB in $1.1 \times 10^{-3}$4 seconds, compared with $1.1 \times 10^{-3}$5 dB in $1.1 \times 10^{-3}$6 seconds for DiffVG and $1.1 \times 10^{-3}$7 dB in $1.1 \times 10^{-3}$8 seconds for Bézier Splatting. The difference suggests that Windfoil’s per-step cost and GPU execution model become increasingly advantageous as the scene grows.

On Kodak, Windfoil reaches or exceeds DiffVG’s final scored quality on 20 of 24 images, with a median parity speed-up of $1.1 \times 10^{-3}$9 on those images. It reaches Bézier Splatting’s final quality on all 24 images, with a median speed-up of $1.6 \times 10^{-3}$0. These parity ratios measure the baseline’s full optimisation time divided by the time Windfoil needs to reach the baseline’s final PSNR; they are not end-to-end speedups under identical training schedules.

Figure 3: Wall-clock convergence on Färlev at 512 shapes; Windfoil crosses 21.4 dB at 1.0 seconds, compared with 38 seconds for DiffVG and 94 seconds for Bézier Splatting.

At a fixed 10,000-step budget on Färlev, Windfoil exceeds Bézier Splatting by $1.6 \times 10^{-3}$1 dB with 512 shapes and by $1.6 \times 10^{-3}$2 dB with 4,096 shapes. The reported parity speed-ups are $1.6 \times 10^{-3}$3 and $1.6 \times 10^{-3}$4, respectively. At $1.6 \times 10^{-3}$5 resolution, Windfoil reaches $1.6 \times 10^{-3}$6 dB with 10,000 shapes in $1.6 \times 10^{-3}$7 seconds and $1.6 \times 10^{-3}$8 dB with 50,000 shapes in $1.6 \times 10^{-3}$9 seconds. No baseline measurements are provided at those shape counts, so these results demonstrate Windfoil’s scaling but do not establish comparative superiority there.

The experimental protocol also limits the strength of the numerical conclusions. Each benchmark was run once with a shared initialisation seed, and the paper notes that host CPU efficiency can affect timing. The results are therefore strong engineering measurements but not variance estimates across seeds, machines, or optimisation schedules.

Use cases and system implications

The paper demonstrates three uses beyond direct rasterisation and MSE fitting. First, variable filter widths permit coarse-to-fine optimisation by beginning with broad coverage and annealing toward a one-pixel footprint. Second, independent pixel evaluation enables tiled print rendering with floating-point compositing and potential support for high-bit-depth, wide-gamut, and HDR output. Third, a Python loss server supplies CLIP gradients for text-to-sketch synthesis.

For CLIP-guided synthesis, Windfoil optimises curve control points and appearance toward text prompts, with examples using translucent rectangles and several random seeds. The paper reports lower CLIP loss than DiffVG at 64, 128, and 256 shapes and experiments with scenes containing up to 100,000 shapes. These results demonstrate compatibility with semantic objectives, but the evaluation is less quantitatively developed than the MSE benchmarks: the paper does not provide a comprehensive prompt-level table or variance analysis for these experiments.

The same coverage model used for display and optimisation is conceptually important. Optimised parameters are evaluated by the renderer that will eventually display them, reducing a source of train–render mismatch. This does not eliminate optimisation pathologies associated with piecewise differentiability, compositing order, or perceptual losses, but it removes one avoidable inconsistency.

Limitations and open questions

The principal limitation is the noncommutativity between filtering and fill-rule evaluation. Windfoil integrates winding and applies the fill rule afterward, which is exact only under restricted winding configurations. The self-crossing rosette demonstrates a visible failure. A remaining question is whether a more expensive local treatment—such as adaptive subdivision or additional per-fragment samples only where winding variation exceeds one—can preserve the method’s throughput while recovering exact filtered coverage at problematic contours.

The footprint is axis-aligned in curve coordinates. It is exact under translation and axis-aligned scaling, but not under general rotation, shear, or perspective transformation. Extending the boundary integral to transformed pixel footprints would be necessary for a renderer with fully general projective invariance.

Filtering each shape before source-over compositing also differs from filtering the fully composited scene. This matters where adjacent translucent shapes meet, and the paper does not quantify the resulting error separately from winding-related errors. Similarly, the minification guard uses an approximate ink profile and is disabled during the primary fidelity validation, leaving open how the approximation affects measured accuracy in realistic zoomed-out workloads.

Finally, the supported primitive set is narrow: closed quadratic contours only. Cubic curves and strokes must be converted to quadratic closed outlines, while clipping, gradients, textures, and paint effects are absent from the differentiable path. Fixed-point integer atomics provide deterministic gradient accumulation but introduce quantisation and possible overflow. The reported optimisation results therefore apply most directly to scenes that can be represented naturally by closed quadratic shapes.

Conclusion

Windfoil presents a unified analytic renderer for real-time and differentiable vector graphics. Its core contribution is a closed-form, per-pixel integration of quadratic Bézier winding over rectangular footprints, implemented through Green’s theorem and accelerated with row-band and tiled data structures.

Against the paper’s supersampled box-filter reference, Windfoil achieves substantially lower mean absolute coverage error than the evaluated Slug and Skia configurations. Its real-time performance is competitive with Slug, while its WebGPU differentiable backend produces large optimisation-time reductions relative to DiffVG and Bézier Splatting in the reported image-fitting experiments. The strongest results occur at high shape counts, where Windfoil reaches $1.2$0 dB with 4,096 shapes in $1.2$1 seconds.

The method’s advantages are conditional on its representation and coverage assumptions. It is not exact for all filled shapes, does not support general transformed footprints, and currently lacks native handling for several standard vector-graphics features. Within those constraints, the paper establishes a technically coherent connection between analytic antialiasing and differentiable vector rendering, with the shared coverage model serving as its principal systems-level contribution.