GPUHardware

How To Configure 2026 Flux.1 CoreML Multi-Resolution: Fixed Sizes Or Preset Sizes

How To Configure 2026 Flux.1 CoreML Multi-Resolution: Fixed Sizes Or Preset Sizes

A Flux.1 pipeline that accepts several resolutions can still lose Neural Engine coverage, trigger mixed execution, and add avoidable model-management work.

Fastest decision: use fixed shapes for one production size, EnumeratedShapes for a small known set, and a bounded RangeDim only when incoming dimensions cannot be predicted. Keep a CoreML path for verified sizes and a GPU path for everything else.

This is for Mac application engineers supporting square, landscape, and portrait Flux.1 output; AIGC teams producing batches at fixed specifications; and technical leads validating an M-series Mac deployment across more than one machine. It is not a generic conversion tutorial. The decision here is how much input-shape flexibility the deployment can carry without weakening verification.

Last updated September 11, 2026. The technical claims below were checked against Apple’s Core ML Tools documentation, official API guidance, and the official coremltools release record. Flux.1 model and conversion-script behavior remains version-dependent and should be reproduced locally.

Flux.1 CoreML multi-resolution starts with coverage, not maximum flexibility

Flux.1 can be packaged around three input-shape strategies:

  • Fixed shape: one declared height and width.
  • EnumeratedShapes: a finite list of accepted shape alternatives.
  • Bounded RangeDim: a declared range for a dimension, with runtime values constrained by that range.

Apple documents these flexible input mechanisms, including enumerated and ranged dimensions, in its Flexible Input Shapes documentation. The existence of the API does not mean every Flux.1 component, tensor, or custom node will accept the same shape policy.

The first screening rule is simple:

  • If the production task has one stable output size, start with a fixed shape.
  • If the product supports a short list of known sizes, start with EnumeratedShapes.
  • If the request dimensions are genuinely unpredictable, evaluate a bounded range.
  • If a range is only being added to avoid maintaining a few presets, do not use it by default.

A square batch workflow is usually the easiest case to validate. A poster generator may need one landscape family and one portrait family. A user-facing image tool may receive dimensions that the engineering team cannot predict in advance. These are different deployment problems, even if they all appear under the label “multi-resolution.”

A broad range does not automatically cover every requested aspect ratio. Flux.1’s text, latent, image, and post-processing components must agree on compatible tensor relationships. A size accepted by one converted component can still fail at another boundary. This is why the question is not simply whether Core ML can switch resolution. The question is whether the complete pipeline can switch resolution and remain supported, measurable, and visually consistent.

Fixed, preset, and range shapes make different trade-offs

The three options should not be ranked by flexibility alone.

Fixed shape

A fixed model has the smallest accepted input contract. That limits coverage, but it also makes the deployment state easier to reason about.

Advantages

  • One declared geometry is easier to validate.
  • Input preprocessing has fewer branches.
  • Model selection and cache behavior are easier to document.
  • A failure can usually be tied to the single supported size rather than a shape-selection rule.

Costs

  • A second production resolution may require another model artifact.
  • Landscape and portrait requests may need separate fixed paths.
  • A request outside the contract must be resized, rejected, or routed to another backend.

Fixed shape is the default choice for a batch team whose customers already require a known specification. It is also a strong baseline for comparing Neural Engine participation because fewer runtime shape variables are present.

EnumeratedShapes

EnumeratedShapes sits between fixed and fully dynamic input. The model declares a finite set of alternatives rather than accepting an open-ended range. Apple’s documentation describes enumerated shapes as a way to provide known alternatives that Core ML can optimize for, rather than leaving every dimension open at runtime. The exact conversion and runtime behavior still depends on the model graph and the operating-system implementation.

Advantages

  • Several approved square, landscape, or portrait sizes can share one logical model package.
  • The application can reject unapproved dimensions before inference.
  • Each preset can receive its own visual and performance acceptance record.
  • The runtime has more shape information than it would with a broad unconstrained policy.

Costs

  • Every listed size increases the validation surface.
  • A preset can be accepted by the interface but still fail inside a Flux.1 component.
  • Switching between presets can expose a first-use or device-optimization event that a single-size test never sees.
  • Adding a new size is a model change, not merely a UI change.

For a product with a finite output menu, EnumeratedShapes is usually the most balanced starting point. It preserves controlled flexibility without pretending that arbitrary dimensions are equally supported.

Bounded RangeDim

RangeDim is intended for cases where the input cannot be reduced to a small list. A bounded range is safer than an unbounded concept because the deployment still defines limits. However, a range is not a promise of equal optimization across every value in that interval.

Advantages

  • The application can accept more dimensions without shipping one fixed artifact per size.
  • User-generated or externally supplied dimensions may fit the contract.
  • The backend can keep one dynamic decision path, provided all components honor the same constraints.

Costs

  • Runtime graph partitioning may vary by shape.
  • Unsupported operations or reshape patterns may move part of the workload to another compute unit.
  • Memory behavior can change with the actual tensor dimensions.
  • A successful model load says little about the quality of every runtime shape.
  • Debugging becomes harder because the failing dimension may be an edge case.

A range should therefore be treated as an engineering hypothesis. It needs a boundary test, common-size test, aspect-ratio test, and fallback test. It is not a substitute for a finite acceptance matrix.

Apple Neural Engine access is a verification result, not a setting

The phrase “run Flux.1 on the NPU” hides three separate questions.

First, does the Core ML model permit the Apple Neural Engine to participate? Second, does the compiled model actually place relevant operations there? Third, does the end-to-end Flux.1 pipeline gain enough from that placement to justify the shape strategy?

Core ML supports compute-unit configuration, but selecting a configuration does not guarantee that the complete graph will execute on the Neural Engine. Apple’s Core ML compute-unit guidance describes the available execution choices. The MLComputePlan documentation provides a way to inspect compiled-model planning information. Those tools help establish what the model can use; they do not turn an unsupported operator into an Neural Engine operator.

Static shapes generally give the compiler the most constrained input contract. EnumeratedShapes provides several known contracts. RangeDim provides a wider contract that can require more runtime handling. This is an engineering comparison, not a guarantee that fixed shapes will always win for every Flux.1 export.

The most common reasons for mixed execution include:

  • A tensor operation is not supported by the selected accelerator.
  • A dynamic reshape changes the graph pattern.
  • A converted component uses a shape relationship that another component does not preserve.
  • A custom ControlNet or other extension crosses a boundary that was not included in the Core ML conversion.
  • Input or output conversion remains outside the main compiled graph.
  • A precision or type choice prevents one segment from using the preferred device.

For that reason, the acceptance record should state “Neural Engine participation observed for these components and these sizes,” not “the entire Flux.1 model runs on the NPU.” The distinction matters when comparing temperature, power, and latency.

A configuration matrix should separate coverage from risk

The table below is a planning tool. It does not claim a universal winner or a fixed performance result.

Strategy Resolution coverage Device-side optimization outlook Startup and switching risk Memory and maintenance profile Recommended use
Fixed shape One approved geometry Narrowest input contract Lowest shape-selection complexity More artifacts if many sizes are needed Single-spec production batches
EnumeratedShapes Finite approved geometries Known alternatives can be optimized and checked individually Preset changes require separate first-use testing One package, but a larger validation matrix Products with a controlled size menu
Bounded RangeDim Values within declared bounds More runtime variability; actual partitioning must be inspected Highest edge-case and switching uncertainty Fewer artifacts, potentially wider runtime pressure Unpredictable input sizes with a tested fallback

The practical decision is not “which option is most advanced?” It is “which option keeps the number of unverified states low enough for the product team to own?”

A batch-rendering team may prefer several fixed artifacts if the output contract is strict and the deployment process already handles model selection. An application with a short menu may prefer EnumeratedShapes. A consumer-facing editor may need RangeDim, but it should still preserve a GPU route for dimensions that fail validation or produce an unacceptable plan.

Step one: define shape contracts before converting

Write the shape contract in application terms before touching the conversion script.

Record:

  1. Approved square outputs.
  2. Approved landscape outputs.
  3. Approved portrait outputs.
  4. The dimensions that must be rejected.
  5. The dimensions that may use GPU fallback.
  6. Whether the application can select a model before creating the Core ML request.

Do not describe the contract as “all resolutions.” That phrase is not testable. State the actual accepted dimensions or the exact lower and upper bounds. If the request list is small, it is already evidence in favor of fixed shapes or EnumeratedShapes.

The Core ML input and output type documentation should be used to confirm that the exported interface matches the application’s preprocessing and output expectations. Shape support is not only a width-and-height decision. The tensor type, layout, and conversion boundary also matter.

Step two: keep conversion variables locked

Do not compare shape strategies while changing several other variables. Lock the following for the first comparison:

  • Flux.1 model revision and license-approved model files.
  • coremltools release.
  • macOS and Core ML runtime.
  • Precision and quantization policy.
  • Prompt, seed, sampler, and generation settings.
  • Preprocessing and post-processing code.
  • Batch behavior.
  • Compute-unit configuration.

The official coremltools repository and its release history are the authoritative places to check conversion capability changes. Community scripts may support particular Flux.1 versions, but their support is third-party until the exact pipeline has been reproduced.

This is also where custom nodes require caution. A ControlNet extension or custom conditioning path may not map cleanly into the same Core ML package. If a component remains outside Core ML, measure it as part of the complete pipeline rather than describing the result as full Neural Engine execution.

Step three: measure compilation, first use, switching, and steady state separately

A single wall-clock number is not enough.

Create separate records for:

  • Model package compilation.
  • Device-specific optimization or preparation.
  • First execution at the default size.
  • First execution after switching to another preset.
  • Repeated execution at the same size.
  • GPU fallback execution for an unsupported size.

Do not invent or copy timings from a different Mac. No verified ProxyMac measurement is provided for these shape strategies, so this article does not claim compilation time, generation time, memory peak, temperature, or power results.

The separation is important because the user experience can fail in different places. A fixed model may have a simple runtime but require multiple artifacts. An EnumeratedShapes package may load once but show a noticeable first-use event after selecting a less common preset. A RangeDim package may accept the request while producing a different execution plan for the actual dimensions.

Apple’s typed execution guidance is relevant when checking whether the converted model’s types and execution assumptions remain stable. It does not replace end-to-end Flux.1 measurements.

Step four: measure the complete pipeline, not only the Core ML submodel

Memory and heat cannot be inferred from a compute-unit setting.

The test should include:

  • Text encoding.
  • The Flux.1 denoising components.
  • Latent allocation.
  • Input conversion.
  • Output conversion.
  • Any GPU fallback segment.
  • Model loading and cache effects.
  • Application overhead.

Multiple fixed artifacts can increase storage and loading complexity. One EnumeratedShapes package can simplify delivery but still require preset-specific testing. A bounded range can reduce artifact count while increasing runtime variability. None of these effects should be converted into an exact memory, temperature, or power claim without same-device measurements.

The test batch should use the same prompt set and the same output policy. Keep cold-start and warm-run records separate. If a team only measures a warm run at the default square size, it cannot safely generalize the result to portrait or landscape requests.

Step five: use visual consistency as a release gate

Hardware placement is only one part of a production decision. An image pipeline also has to preserve output behavior.

For each approved aspect ratio, keep the prompt, seed, generation settings, and post-processing path constant. Compare:

  • Composition completeness.
  • Edge artifacts.
  • Unexpected cropping.
  • Color shifts.
  • Structural changes.
  • Obvious numerical or tensor-type deviations.
  • Failure behavior at the nearest unsupported dimension.

A difference does not automatically prove that the Neural Engine caused it. The cause may be input preprocessing, a precision conversion, a model revision, a latent-size mismatch, or a component that took a different execution path.

If one preset fails the visual gate, remove it from the CoreML route. Route it to a verified fixed model or the GPU path. A smaller supported matrix is better than a wide matrix that silently changes output quality.

What should be checked before a production decision?

The following checklist is designed for a release review rather than a one-off experiment:

  • [ ] The Flux.1 model revision and conversion dependencies are recorded.
  • [ ] Every supported square, landscape, and portrait size is named explicitly.
  • [ ] The application rejects dimensions outside the contract before inference.
  • [ ] Fixed, EnumeratedShapes, and bounded RangeDim candidates were compared with the same model settings.
  • [ ] Default-size first execution is recorded separately from steady-state execution.
  • [ ] Non-default preset switching is recorded separately from default-size execution.
  • [ ] Compiled-model planning information is retained for each candidate.
  • [ ] Neural Engine participation is described per component or graph segment, not assumed for the whole pipeline.
  • [ ] GPU fallback behavior is tested with an intentionally unsupported or unverified size.
  • [ ] Memory includes model loading, conversions, and fallback work.
  • [ ] Temperature and power come from the same device, task, and batch.
  • [ ] Visual checks use fixed prompts, seeds, and post-processing.
  • [ ] The default size, cache policy, rollback model, and re-test trigger are documented.
  • [ ] A coremltools, macOS, model, or conversion-script update triggers the matrix again.

Teams evaluating temporary machines can also review the ProxyMac console during a controlled test run, then keep the acceptance record independent of the rental interface. The model decision should remain reproducible on the target M-series Mac rather than being based on a single informal session.

The final matrix should favor a smaller verified surface

The production conclusions are conditional.

Choose fixed shape when: the task has one stable output specification, visual consistency is strict, and another size can use a separate model or GPU route.

Choose EnumeratedShapes when: the product has a finite size menu and the team can test every approved alternative. This is usually the most defensible compromise for square, landscape, and portrait support with controlled options.

Choose bounded RangeDim when: incoming dimensions cannot be predicted, the bounds are meaningful, and the team accepts that some requests may use mixed execution or GPU fallback.

The safest Flux.1 deployment is often dual-track: verified CoreML routes for common sizes, plus a GPU route for unverified or unpredictable dimensions. That design acknowledges the difference between permitted Neural Engine use, actual graph placement, and end-to-end benefit.

A long-term local purchase can be appropriate for stable, heavy workloads and physical-device requirements. The drawbacks are less flexibility during validation, hardware tied to one test configuration, and the risk of buying before the shape matrix is complete. A generic cloud GPU can introduce a different software and accelerator stack, so its result may not predict an M-series Mac deployment. For this decision, a periodic ProxyMac Mac environment is useful when the team needs to compare fixed, preset, and bounded strategies before committing to hardware. The ProxyMac help center can be used alongside the internal test plan, while the final acceptance record should still include the exact model and runtime versions.

Once the three paths have been tested on the target class of Mac, the choice becomes concrete: fixed for one specification, presets for a controlled menu, and CoreML plus GPU fallback for unpredictable input. That is a better basis for a purchase or deployment decision than assuming that a broader dynamic range will automatically deliver more Neural Engine acceleration.

Test Flux.1 CoreML on a Remote Mac

Use ProxyMac to compare fixed sizes, EnumeratedShapes, and bounded RangeDim inputs on real Apple silicon hardware.
Choose a Mac configuration that fits your CoreML compilation, memory, and batch-generation workload.