PaladinsGTX/low-poly-palette-forge

A browser-native atelier where color palettes become woven grids, and grids become game-ready texture sheets. Built for indie studios, solo world-builders, and anyone who thinks in pixel blocks instead of brush strokes.

VoxelWeave Studio is a generative texture workshop that lives entirely inside your browser. Instead of painting every tile by hand, you describe a mood, a palette, and a weave density — and the tool spins out seamless, low-poly-friendly texture grids that slot directly into modern and retro game engines alike.

Think of it as a loom for pixels: you feed it color reels, it returns fabric. Every output is deterministic, tileable, and exportable as a compact texture atlas with a machine-readable palette manifest.

This repository is the home of the whole workshop — the editor, the generator core, the palette reasoning engine, and the export pipelines.

Most texture generators treat color as a happy accident. VoxelWeave treats color as the primary citizen. The architecture is palette-first: every procedural decision cascades from a curated or generated palette, so the final sheet remains visually coherent even at extreme grid densities.

We believe low-poly art thrives on constraint. A tight palette plus a disciplined grid produces textures that read cleanly at 64×64 and still feel intentional at 512×512.

• Palette-Anchored Generation — Every texture derives from an explicit palette definition, ensuring stylistic unity across a whole project.
• Grid Weave Engine — Configurable rows, columns, cell padding, and edge bleed for crisp tiling.
• Deterministic Seeds — Reproduce any texture exactly by sharing a seed string.
• Live Preview Grid — Watch the weave update as you tune parameters, with zero page reloads.
• Multi-Format Export — Atlas sheets, individual tiles, and palette manifests in one pass.
• Palette Importers — Bring in palette files from common color-list formats and image sampling.
• Batch Mode — Queue dozens of variants and export them in a single archive.

• Engine-Agnostic Output — Neutral PNG atlases with sidecar JSON descriptors.
• Manifest Schema — A predictable JSON layout mapping palette indices to tile coordinates.
• Naming Conventions — Optional slugged naming so imported assets drop straight into content pipelines.
• Mipmap-Aware Padding — Optional gutters to survive downsampling without bleeding.

• Responsive UI — A layout that folds gracefully from ultrawide monitors down to tablets.
• Dark & Light Skins — Two chroma-tuned themes for long evening sessions.
• Keyboard-First Workflow — Shortcuts for regenerate, export, and palette cycling.
• Undo Timeline — A scrollable history of parameter states, not just pixel diffs.
• Offline Capable — Once loaded, the forge keeps working without a network connection.

• Multilingual Support — Interface strings available across a growing set of locales.
• Reduced-Motion Mode — Calmer transitions for motion-sensitive creators.
• Contrast-Safe Palette Warnings — Flags palette pairs that may blur together.
• Screen-Reader Labels — Descriptive roles on all interactive controls.

• 24/7 Customer Support — A round-the-clock help desk for studios shipping on deadline.
• Documentation Vault — Deep guides on palette theory and grid math.
• Community Palette Exchange — Share and discover palette reels with other creators.
• Issue Triage Board — Transparent roadmap and prioritization.

The workshop is split into cooperating layers, each replaceable without disturbing the others.

1. Palette Layer — Parses, validates, and normalizes color reels. Handles perceptual sorting and contrast scoring.
2. Weave Layer — Converts grid parameters plus palette into a tile matrix. This is where the low-poly signature emerges.
3. Render Layer — Paints the matrix to a canvas, applies padding, and prepares export buffers.
4. Export Layer — Serializes atlases, tile sets, and manifests; handles compression and packaging.
5. Shell Layer — The responsive interface, localization strings, and state timeline.

Because these layers communicate through plain data contracts, you can script the weave engine headlessly or embed the render layer in another web tool.

Color is the skeleton of low-poly art. A texture that ignores its palette looks like noise; a texture built from its palette looks like intent.

VoxelWeave enforces three quiet rules:

• Rule of Constraint — Limit palettes to a small, deliberate set. Fewer colors force stronger silhouettes.
• Rule of Neighbors — Adjacent grid cells should differ enough to read, but not so much that they vibrate.
• Rule of Return — Every palette color should appear at least once across a sheet, so nothing feels orphaned.

These rules are not hard limits. They are defaults that keep beginners out of trouble and give veterans a baseline to rebel against.

• Indie Game Developers building stylized worlds on a budget of time.
• Technical Artists who want reproducible texture batches from scripts.
• Modders reviving older engines with fresh, coherent art sets.
• Educators teaching color theory through tangible, playable output.
• Hobbyists who simply enjoy watching grids bloom into texture.

• A modern component-driven front-end for the shell and editor.
• A canvas-centric render pipeline for high-throughput tile painting.
• A worker-based generation core to keep the interface buttery smooth.
• A schema-validated export module for predictable downstream parsing.
• Localized string bundles loaded lazily per locale.

Everything runs client-side. Your palettes and textures never need to leave your machine.

You do not need a package manager to begin. Follow this gentle path:

1. Open the hosted studio page in any current browser.
2. The default palette reel loads automatically and paints a starter grid.
3. Adjust Rows, Columns, and Cell Size in the left panel to taste.
4. Pick a palette or import your own color reel.
5. Press Weave to regenerate. Press Export to download your atlas and manifest.
6. Drag the resulting files into your project's texture folder and wire up the manifest.

For teams that prefer automated pipelines, the generation core can be invoked from a script using the documented data contracts. No system-level installation steps are required; the studio is self-contained.

• Vector Tile Export — crisp scalable variants for UI overlays.
• Animated Weave — palette cycling across frames for shader-style effects.
• Palette Suggester — mood-based palette proposals from a text prompt.
• Plugin Bridge — connect to popular editor ecosystems via neutral manifests.
• Cloud Sync (Optional) — opt-in project sync for distributed teams.
• Collaborative Sessions — shared live editing for art jams.

This project sits at the intersection of procedural texture generation, low-poly game art tooling, palette-driven design, tileable grid textures, seamless texture atlas export, browser-based texture editor, multilingual creative software, responsive web tooling, and deterministic asset pipelines. If you were searching for a palette grid texture generator built for game engines, you have found the workshop.

VoxelWeave Studio is provided as-is for creative and educational purposes. Generated textures are yours to use in personal and commercial projects. The maintainers are not responsible for how outputs are deployed in third-party engines, nor for any compatibility issues arising from custom manifests. Palette imports from external sources remain subject to the licenses of those sources. Always verify that any palette you import is cleared for your intended use. Features described in the roadmap are aspirational and may shift as community feedback arrives.

This project is released under the MIT License. You may use, modify, and distribute it in accordance with the terms of that license.

Read the full license text here: MIT License

Copyright (c) 2026 VoxelWeave Studio contributors.

Texture work does not have to be a slog of pixel nudging. When color leads and grids follow, art production becomes a rhythm — reel in, weave out, ship the world.