Field Tile

Lattices, not just checkerboard

Field Tile gives you four repeating patterns - checker, brick, herringbone, hex - as masks. That sounds like a texture generator, and it is, but the more useful framing is that it's a lattice builder: the geometry is exact, resolution-independent, and jittered per cell deterministically. That combination makes it the tool for tileable backing patterns, floor and wall textures you're going to composite into a generation, paving-stone and mosaic masks, and - less obviously - evenly spaced grids of cells you then modulate with a profile.

tiles counts cells across the reference dimension S = max(width, height), so pattern scale stays constant as you change resolution. lock_square (on by default) keeps cells exactly square, which is why the vertical count is usually a consequence rather than a setting; turning it off exposes tiles_y for checker and brick separately. Herringbone and hex have fixed geometry ratios - their cells aren't independently scoped in x and y - so tiles_y doesn't apply to them at all.

Pattern-specific widgets: row_offset for brick, where 0.5 is a standard running bond and 0 is stacked, and mortar, the grout width as a fraction of the cell's short side. mortar is what turns a checkerboard into a tiled surface - without it you've got hard-edged cells meeting each other and it reads as abstract, not as masonry. rotation rotates the whole lattice about the frame centre.

Profiles are where it stops being a checkerboard

profile shapes each cell from its own distance field: flat, pyramid, cone, gaussian, bevel. This is the nice abstraction - "pyramids" or "rounded tiles" isn't a separate pattern, it's a profile applied to whatever lattice you already have. So a hex lattice with a gaussian profile is a field of soft bubbles; the same lattice flat is a honeycomb. profile_width controls the falloff for the gaussian and bevel profiles.

Then the jitter: jitter_size, jitter_offset (which needs mortar > 0 to have room to move) and jitter_value, all driven by seed. Each varies cells independently and deterministically, and jitter_value is the one that gives cells different brightnesses so a flat pattern stops looking machine-made.

Every cell edge passes through an exact box-filter coverage function, so tile edges antialias identically to Field Shape's contours. No stair-stepping at low tiles values.

Inputs and outputs

The full widget set: pattern, tiles, lock_square, tiles_y, row_offset, mortar, rotation, profile, profile_width, jitter_size, jitter_offset, jitter_value, seed, aa_width, distribution, coverage, invert, width, height - plus the same optional reference_image / reference_mask the other generators take.

Outputs: mask and preview.

The seed widget is only active when a jitter is above zero, which is worth knowing before you conclude it's broken. With all jitters at 0 the lattice is fully determined by the geometry widgets and the seed has nothing to do.

Install

ComfyUI Manager → search ComfyUI Field, or:

cd ComfyUI/custom_nodes
git clone https://github.com/jeremieLouvaert/ComfyUI-Field

Restart ComfyUI. No models, no extra dependencies beyond the torch ComfyUI already ships. It's under AKURATE/Fields/Generate.

How to actually use it

The straightforward use is texture: build the tile mask, invert it, and composite a material through it with Field Composite. Mortar plus jitter plus a pyramid profile gives you something that reads as actual tilework once lighting is painted in.

The less obvious use is as a grid. Set pattern to checker, tiles to 12, mortar to something wide, and you've got a regular array of cells. Combine that with Field Scatter or with Field From Image and you can modulate a repeating layout by image content - the same mask, but some cells respond and others don't.

And the resolution test that makes this pack worth it: set tiles to 8, render at 512, then render at 2048 with everything else unchanged. Same pattern, same cell count, just finer. If you've ever had a tiling pattern double its frequency when you bumped the resolution, that's the bug this avoids.

Getting burned

mortar is a fraction of the cell's short side, not of the frame, so it scales with your tile count. Raise tiles from 8 to 20 and your mortar gets proportionally thinner in frame terms - you may need to raise mortar to keep grout lines visible.

jitter_offset silently does nothing with mortar at 0, because there's no gap for cells to move into. That's a documented dependency, not a broken widget, but it catches people who set the jitter first and the mortar later.

And tiles_y is inert on herringbone and hex. If you're on hex and the vertical count refuses to change, you're not doing anything wrong - the lattice geometry doesn't have that degree of freedom.