Floniks
Workflows vs Single Steps

An NFT/Generative-Collection Workflow

Updated 2026-06-19·14 min read
Key takeaway

Generative art collections require hundreds or thousands of unique images assembled from combinatorial trait layers — background, body, clothing, headwear, accessories — each combination verified for rarity balance and visual compatibility before minting. This guide explains how to build an NFT and generative-collection workflow in the Floniks editor: defining trait layers and rarity weights, generating base assets for each trait variant, compositing trait combinations into final collection images, running a compatibility and rarity check, and exporting collection-ready files with metadata. The workflow scales from a hundred-piece artist edition to a ten-thousand-piece generative drop.

How Generative Collections Work and Why They Need a Workflow

A generative art collection is built from a set of trait layers. Each layer — background, skin or surface, clothing, headwear, accessory, special effect — has multiple variants. The collection is produced by selecting one variant per layer for each token, generating or compositing the combination, and recording the traits in the token metadata. A ten-trait-layer collection with ten variants per layer has ten billion possible combinations, though in practice a collection of ten thousand tokens draws from a much smaller pool, and rarity is engineered by assigning different selection weights to each variant.

The production challenge is not creative — the trait artwork is designed by the artist. The production challenge is logistics: ensuring that every combination is visually compatible (a "space helmet" headwear should not appear over a "cowboy hat" body), that the rarity distribution across the collection matches the intended distribution (legendary traits should appear in approximately one percent of tokens, not five percent), and that every token image and its corresponding metadata file are correctly named, formatted, and linked before the collection goes to the smart contract.

Manual production of a ten-thousand-piece generative collection is effectively impossible without automation. The Floniks generative-collection workflow handles the entire pipeline: trait layer definition, variant generation, combination sampling with rarity weighting, compatibility filtering, composite image generation, rarity verification, and metadata export. The artist's role is to define the trait library and approve the per-trait artwork; the workflow handles the combinatorial production.

Defining Trait Layers and Rarity Weights

The trait system is the collection's creative and economic architecture. In the Floniks editor, add a Trait Config node that defines the complete trait structure: the ordered list of layers, the variants within each layer, the rarity weight for each variant, and any compatibility constraints.

The rarity weight for each variant is specified as a percentage of the total collection. A common distribution model uses four rarity tiers: Common (40-60% of collection), Uncommon (20-30%), Rare (10-15%), and Legendary (1-5%). The Trait Config node validates that the weights within each layer sum to 100% and that the combination of weights across layers produces the target distribution for the full collection before any generation begins.

Compatibility constraints are rules that prevent visually incompatible trait combinations. The most common types are exclusive pairs ("space_helmet" headwear is incompatible with all other headwear variants and with any non-futuristic clothing variants), inclusive requirements ("underwater_suit" body requires the "ocean" or "deep_sea" background variants only), and visual dependency constraints ("open_beak" face variant requires a bird base rather than mammal base). These constraints are specified as a rule array in the Trait Config node. The Combination Sampler node reads the rules and filters out invalid combinations during the sampling phase, before any generation credits are spent on compositing an incompatible token.

Generating Base Trait Artwork

Each trait variant must be generated as a standalone asset on a transparent background, positioned and sized to align correctly when composited with the other trait layers. In Floniks, a Trait Generation branch produces all variant images for a given layer.

Add a Trait Generation node for each variant in each layer. The prompt structure for a trait layer item must specify the layer type, the variant description, the art style, and the canvas requirements: "flat vector character art, [LAYER_TYPE] layer, [VARIANT_DESCRIPTION], pixel-perfect edges, transparent background, 2000x2000 pixel canvas, consistent art style with collection base design, centered in frame, no shadows, no backgrounds."

The most important production requirement for trait artwork is layer alignment. Every trait variant in the same layer must occupy the same pixel region of the 2000x2000 canvas. A "hat" variant that sits two pixels higher than the other hat variants will not align with the head layer beneath it, and the misalignment will be visible in every token where that hat appears. After generation, pass all variants through a Layer Alignment Check node that verifies the bounding box of the active pixel content within each layer matches the specification. Variants that fall outside the tolerance are flagged for manual adjustment or regeneration.

Generate all trait artwork before beginning the compositing phase. Review every variant for style consistency, layer alignment, and visual quality. Approve the complete trait library before proceeding. Changes to trait artwork after compositing has begun require recompositing every token that included the revised trait, which is expensive and time-consuming.

Compositing Combinations and Running Compatibility Checks

With the approved trait library in place, the Combination Sampler node generates the token list: the complete set of trait combinations for the collection, each combination representing one token, with trait selection weighted by the rarity distribution specified in the Trait Config.

The Sampler runs the compatibility rules against every generated combination before producing the final token list. Incompatible combinations are discarded and replaced with new samples until the token count reaches the target collection size. The Sampler logs the discarded combination count — a high discard rate indicates that the compatibility rules are too restrictive and may need to be relaxed, or that the trait library needs additional variants to provide more combinatorial flexibility.

The approved token list feeds the Batch Compositor node, which processes each token in the list by layering its trait variants in the specified layer order — background first, then body, then clothing, then face, then headwear, then accessories, then any special effects layers — and composites them into a final flat PNG. The Batch Compositor produces one PNG per token, named by token ID: "0001.png," "0002.png." This naming convention is standard across most NFT platforms and smart contract implementations.

A Post-Composite Quality Check node samples a random subset of tokens — typically five percent of the collection — and verifies layer alignment, consistent art style, absence of transparency artifacts, and correct canvas dimensions. If the quality check flags issues in the sample, the entire batch is reviewed before proceeding to export.

Exporting Collection-Ready Files and Metadata

A complete generative collection delivery package contains three components: the token image files, the metadata files, and the rarity report. The Floniks export branch produces all three in a single run.

The Image Export node produces all token PNG files at 2000x2000 pixels, organized in a numbered folder structure: "images/0001.png" through "images/10000.png." Some platforms require square JPEG files at smaller dimensions for gas optimization — add a JPEG Convert node downstream that produces 1000x1000 JPEG at quality 95 alongside the master PNG, stored in a "jpegs" subfolder.

The Metadata Export node reads the Trait Config and the token combination list and produces one JSON metadata file per token following the ERC-721 metadata standard. Each file contains: "name": "Collection Name #0001", "description": "a brief collection description", "image": the IPFS URI of the token image, and a "attributes" array containing one object per trait with "trait_type" and "value" fields. For example: attribute "trait_type": "Background", "value": "Cosmic Purple" and attribute "trait_type": "Headwear", "value": "Space Helmet" with "rarity": "Legendary." The image URI field is populated with a placeholder that the collection deployer replaces with the actual IPFS hash after uploading the images to a decentralized storage provider.

The Rarity Report node produces a CSV and a JSON summary of the trait distribution across the collection: for each trait variant, the count of tokens that include it, the percentage of the collection, and the deviation from the target weight. The rarity report is the quality assurance document for the collection economics. Review it carefully before launch — a variant that appears in 3% of the collection when it was intended to appear in 1% will disappoint buyers who paid a premium for a "legendary" item and then discover it is more common than advertised.

Step by step

  1. 1

    Open the editor and add a Trait Config node

    Navigate to /editor and create a new workflow. Add a Trait Config node. Define the layer order (background, body, clothing, face, headwear, accessories, special effects). For each layer, list the variant names and their rarity weights as percentages. Add compatibility rules as a rule array. Verify that weights in each layer sum to 100%.

  2. 2

    Generate all trait variant artwork for each layer

    Add a Trait Generation node for each variant in each layer. Use the prompt structure: "flat vector character art, [LAYER_TYPE] layer, [VARIANT_DESCRIPTION], transparent background, 2000x2000 pixel canvas, consistent art style, centered, no shadows." After generation, run all variants through a Layer Alignment Check node. Revise and regenerate any variants that fail the alignment check.

  3. 3

    Run the Combination Sampler to generate the token list

    Add a Combination Sampler node connected to the Trait Config and the approved trait library. Set the target token count. Run the sampler. Review the discard rate — if it exceeds 20%, relax one or more compatibility rules or add additional trait variants. Review the sampled rarity distribution in the sampler output and confirm it matches the target distribution before proceeding.

  4. 4

    Run the Batch Compositor to produce all token images

    Connect the approved token list from the Combination Sampler to a Batch Compositor node. Configure the layer compositing order to match the visual stacking — background at the bottom, special effects at the top. Run the compositor. After completion, review the Post-Composite Quality Check report and manually inspect flagged tokens before approving the full batch.

  5. 5

    Export token images, metadata files, and the rarity report

    Connect the approved compositor output to three parallel export nodes: Image Export (PNG 2000x2000 in "images" folder, optional JPEG 1000x1000 in "jpegs" folder), Metadata Export (ERC-721 JSON per token in "metadata" folder, with IPFS URI placeholder in the image field), and Rarity Report (CSV and JSON summary). Verify all file counts match the target token count before delivering the package.

  6. 6

    Upload images to decentralized storage and update metadata with real URIs

    Upload the "images" folder to your chosen decentralized storage provider to obtain the base IPFS CID or Arweave transaction ID. Use a Metadata URI Update script (or re-run the Metadata Export node with the real base URI) to replace the placeholder in every metadata file with the actual storage URI. Verify five to ten metadata files manually before deploying the smart contract.

FAQ

How do you handle animated NFTs or collections that include both static and animated traits?+

For animated traits, the Trait Generation node produces a sprite sheet or an image sequence rather than a single static PNG. The Batch Compositor supports mixed-type layers: static PNG layers composite normally, while animated layers produce a GIF or a WebM output per token. The metadata for animated tokens includes a "animation_url" field pointing to the animated file alongside the static "image" field for platform preview thumbnails.

What is the maximum collection size the workflow can handle in a single run?+

The workflow handles collections of any size through batch processing. For collections above five thousand tokens, split the Batch Compositor into batches of one thousand to two thousand tokens each and run them sequentially. Each batch produces its numbered token set. The Collect node assembles all batches into the final delivery package. This batch approach also makes it straightforward to rerun a specific subset if a quality issue is found in part of the collection without reprocessing the entire set.

Related guides

Build it on Floniks

Image, video, digital humans, and reusable workflows on one canvas. Sign up gets you starter credits — no card required.

Explore Floniks