Vaporsoft/ nftySynced 17 Nov 2026, 09:00 UTC

NFTY

A deterministic generator and pixel editor for layered asset collections. Grayscale value-maps colorized at generation time, with OpenSea metadata built in.

Activev2.12.0MIT
git clone https://github.com/corderro-artz/nfty.git
1,139Commits
86Releases
693Downloads
1Contributor

About

Most layered generators composite fixed images from an indexed stack. nfty puts a grayscale colorizer at the core instead: a single value-map is cast to any color by rolling a hue and a saturation over it, with every pixel's own lightness preserved. Those layers are ordered and flattened into one image — the shape its namesake, the web3 NFT collection, is built from — so a handful of drawings becomes thousands of distinct assets.

LicenceMIT
Started21 Jul 2026

Built with

97.1%C#8.2 MB2.8%Python240 KB0.1%PowerShell5 KB0.0%Shell4 KB

Activity

Contents

Readme

Full manualInstallation, guides and reference. The readme below is the short version.

A deterministic generator and pixel editor for layered asset collections.

Most layered generators composite fixed images from an indexed stack. nfty puts a grayscale colorizer at the core instead: a single value-map is cast to any color by rolling a hue and a saturation over it, with every pixel's own lightness preserved. Those layers are ordered and flattened into one image — the shape its namesake, the web3 NFT collection, is built from — so a handful of drawings becomes thousands of distinct assets. A pixel editor is built into the application, so the art and the collection it belongs to are authored in one environment rather than two. The end result is an expansive, reusable asset catalog, or a finished drop with OpenSea metadata written beside every image.

The same book, seed and generation options produce byte-identical output across machines, locales and CPU architectures. nfty reports the exact number of distinct DNA a book admits when it can, and an explicit bound or unknown result when counting is limited. The built-in demo admits exactly 8,745,000 distinct DNA from twenty-nine 32×32 sprites. DNA records the selection and quantized colors; different DNA can still render alike when drawings are identical or hidden.

Download and start in 60 seconds

  1. Download from the releases page (portable if unsure): on Windows unzip it and run Nfty.Desktop.exe; on Linux tar -xzf it and run ./Nfty.Desktop.
  2. Click Open the demo CookBook, then Cook Set, give it a seed such as launch, and pick an empty folder. Fifty distinct chests land in it, numbered, with marketplace metadata beside each.
  3. Click Open Set to browse them, or open a Recipe and click Rise to turn one into a 3D model.

From a terminal (using nfty as an alias for the download's cli/Nfty.Cli executable):

nfty demo .                                                    # writes ChestDemo.cbk here
nfty generate ChestDemo.cbk --count 50 --seed launch --out ./out
nfty menu ChestDemo.cbk --out chest.mnu                        # flatten it for runtime

Using the app rather than working on it? The User Manual is for you; this file is for people building, embedding or changing nfty. The manual's source is in docs/manual/.

A tour

The Explorer on the Chest Demo: 2 recipes, 12 layers, 49 variants, 8,745,000 unique DNAThe Explorer on the Chest Demo: 2 recipes, 12 layers, 49 variants, 8,745,000 unique DNA The Ingredient Editor: a gray value-map, the colorize rail and a live previewThe Ingredient Editor: a gray value-map, the colorize rail and a live preview
Count before you cook. The Explorer reports exact DNA counts, bounds or an unknown result. Draw in gray, color at cook time. The editor is built in; one drawing rolls a hue per asset.
The Set browser: fifty cooked chests with one asset's DNA and trait rarityThe Set browser: fifty cooked chests with one asset's DNA and trait rarity The Rise page on a rolled Chest recipe with its 3D tileThe Rise page on a rolled Chest recipe with its 3D tile
Browse and export. Every asset carries its fingerprint, rarity and, optionally, a 3D model. Rise. Paint depth into a rolled recipe and export glTF.
The viewer showing a chest in 2D and 3D side by sideThe viewer showing a chest in 2D and 3D side by side The Quick Reference sheet with its four tabs and search boxThe Quick Reference sheet with its four tabs and search box
The pop-out viewer. One asset, 2D beside 3D, in its own window. Quick Reference. Keys and terms in four tabs, with search, one click away.

Sealing, spritesheets, the Kitchen and the runtime Menu are in the manual.

Overview

nfty is two front-ends over the same libraries. Dependency-free Nfty.Ticket owns rolling, rules, DNA and Menu reading; Nfty.Core adds authoring archives, imaging, generation, rarity and output, with no UI or CLI dependency. The command line and Avalonia desktop app therefore produce identical bytes from identical inputs and options. A collection is authored as a tree of ZIP archives, generated against a string seed, and published as images plus two sets of per-asset metadata.

Capabilities

Capability Details
Value-map colorization One grayscale drawing rolls a hue and saturation per asset; lightness is the art's, color is the collection's
Three layer kinds Dynamic (rolled color), Static (one fixed color, no RNG), Custom (full-color RGBA, composited as-is)
Counted output space UniqueSpace reports exact DNA counts when computable, otherwise a lower bound, upper bound or unknown result
Deterministic runs SplitMix64 from a string seed; identical output across locales, machines and CPU architectures
Optional layers A per-recipe chance that a layer is left out entirely, added without changing any existing seed's output
Incompatibility rules Exclude and require constraints between named variants, enforced by re-rolling inside a bounded retry budget
Built-in pixel editor Brush, eraser, shapes, line, flood fill, select-and-move, undo/redo — over a value-map or a color raster
Dual metadata Standards-pure OpenSea metadata/NNNN.json plus a rich nfty/NNNN.json with DNA, seed, rarity and per-layer color
Export and sealing Four independent content axes, a plan you read before it writes, and AES-256-GCM sealing for a view-only handoff
Community gallery Browse, download and share cooked Sets with other nfty users from inside the app; sharing uses your own GitHub account, browsing needs none
Extend Re-open a cooked Set, add to it, and recompute rarity across the whole collection
Open formats Ordinary ZIP archives: authoring files and Menus use manifest.json, Sets use set.json, sealed exports use seal.json plus encrypted payload

The Suite

Part What it is Where to start
App (Nfty.Desktop) Avalonia desktop app: Explorer, pixel editor, Set browser, cook and export dialogs Get started
CLI (Nfty.Cli) Every operation headless, for scripts and CI Command line
Ticket (Nfty.Ticket) Dependency-free runtime API: roll an asset's identity from a Menu and a seed Ticket and Menu API
Menu (.mnu) A CookBook flattened with its art, so a runtime rolls and renders with no .cbk Roll assets at runtime
Rise (Nfty.Model) Pixel art to a 3D model (glTF): depth painting, models inside Sets Make a 3D model
Viewer Pop-out window for one asset or model, 2D and 3D View an asset in its own window

More in the User Manual: keyboard shortcuts, settings and the FAQ.

Requirements

Requirement Version Notes
.NET SDK 10.0 Pinned by global.json; needed to build, not to run a release
.NET runtime 10.0 Only for the two framework-dependent download shapes; ordinary .NET Runtime suffices (dotnet-runtime-10.0 on Linux)
Downloads Windows x64, Linux x64 Four shapes for each; no prebuilt macOS download
Source and libraries .NET 10; Ticket also .NET Standard 2.1 Core, CLI and Model tests run on Windows, Linux and macOS; native desktop release checks cover Windows and Linux
Window 1280×720 logical units or larger The app opens at this minimum; OS display scaling affects the physical screen space needed
Python 3.11+ Optional — the manual, the demo generator and the icon build are Python tools

Dependencies

Category Packages
Imaging SixLabors.ImageSharp — pinned to 3.1.11 on purpose; 4.0.0 requires a build-time license key
CLI System.CommandLine
UI Avalonia, Avalonia.Desktop, Avalonia.Themes.Fluent, Avalonia.Skia, Avalonia.HarfBuzz, CommunityToolkit.Mvvm
Composition Microsoft.Extensions.DependencyInjection
Tests xunit.v3, Avalonia.Headless.XUnit, coverlet.collector

Package versions live in Directory.Packages.props and never in a .csproj.

Installation

Prebuilt Windows (x64) and Linux (x64) builds are on the releases page. Every download carries both front-ends, the demo CookBook, and the licenses.

Shape .NET 10 needed For
portable No Unpack and run. Start here if you are unsure.
single-file No One executable per front-end. Unpacks itself on first launch, so that launch is slower.
framework-dependent Yes A smaller folder; needs the .NET 10 runtime.
single-file-net10 Yes One executable per front-end, with the runtime left out.

Archives are named nfty-<version>-<rid>-<shape>.zip on Windows and .tar.gz on Linux (tools/release/build.py makes them; the tarball keeps the executable bits). The app is Nfty.Desktop.exe / ./Nfty.Desktop; the command line sits in the cli folder. On Linux the app needs X11 and font libraries (libice6 libsm6 libx11-6 libfontconfig1 libxrandr2 libxi6 libxcursor1 on Debian/Ubuntu), and ./install-desktop-entry.sh adds a launcher entry and icon for the unpacked copy — see Install nfty.

nfty normally keeps recents, palettes and settings in .nfty beside the executable. When that location cannot be created it tries fallbacks, including $XDG_CONFIG_HOME/nfty (or ~/.config/nfty) on Linux; Settings → DATA shows the active location. Optional launcher/file-type registration and saved Pinata credentials use the operating system's locations. See Settings files and Installation.

To build from source:

git clone https://github.com/corderro-artz/nfty.git
cd nfty
dotnet build nfty.sln

Note: Native AOT is deliberately unsupported. It links, but the resulting app cannot resolve its own views (ViewLocator builds a type name at runtime) or read a .cbk (System.Text.Json reflection). A release must not contain a binary that starts and then does nothing.

Quick Start

A first collection, end to end, against the demo CookBook built into the program — no file to find and no archive to download:

dotnet run --project src/Nfty.Cli -- demo .                 # writes ChestDemo.cbk here

dotnet run --project src/Nfty.Cli -- inspect  ChestDemo.cbk # what is in it
dotnet run --project src/Nfty.Cli -- validate ChestDemo.cbk # is it sound
dotnet run --project src/Nfty.Cli -- stats    ChestDemo.cbk # what odds its weights imply
dotnet run --project src/Nfty.Cli -- generate ChestDemo.cbk --count 8 --seed hello --out ./out

Roll one asset at runtime from a Menu, with no .cbk present:

dotnet run --project src/Nfty.Cli -- menu  ChestDemo.cbk --out chest.mnu
dotnet run --project src/Nfty.Cli -- serve chest.mnu --seed hello --out one.png

Every command takes --threads N (or the NFTY_THREADS variable); output is identical at any count.

The desktop app is the same engine with a UI on top:

dotnet run --project src/Nfty.Desktop

Its Landing screen carries Open the demo CookBook, which unpacks that same book beside the app and opens it. The demo is yours to break, and reopening it keeps whatever you did to it.

The demo is a small collection of layered chests: two Recipes, seven Ingredients covering all three layer kinds, two optional layers, one incompatibility rule, and 8,745,000 distinct assets out of twenty-nine 32×32 sprites — which is the argument for value-map colorization, made in a file you can open.

Concepts

The Six Words

The domain is a cooking metaphor, and the words are the model — the file extensions follow them.

Term File What it is
CookBook .cbk The top-level container: canvas size, collection metadata, weighted Recipes
Recipe .rcp A complete template for one character type — an ordered layer stack plus its incompatibility rules
Ingredient .igt One layer, or trait-category, with its weighted variant images
Variant — A single image with a weight and a name, held inside an Ingredient
Set .set The generated output: images, per-item metadata, rarity, and the seed that made it
Kitchen .ktn A workspace folder of loose parts; its contents are discovered by scanning, never recorded

Generating a CookBook rolls a Recipe per asset, so one book yields a mixed collection. .cbk nests .rcp nests .igt, so the archive layers mirror the domain layers.

Layer Kinds

Kind Source art At generation time
Dynamic Grayscale value-map Rolls a hue and saturation per asset from a weighted range
Static Grayscale value-map Applies one fixed color, deterministically, consuming no RNG
Custom Full-color RGBA Composited exactly as-is; never recolored

Dynamic and static take their value from the grayscale map and only their hue and saturation from the color, which is what multiplies the output space. Custom carries no colorization at all, and Validator refuses one that does.

Depth

A Recipe's layer stack is ordered bottom-to-top, and that order is the paint order — depth 1 paints first and sits furthest back. Because it is a list rather than a stored z, two layers can never share a depth.

nfty move ingredient cat.rcp --id shades --to 3

…or drag a row in the desktop app. Reordering produces a different collection, not a re-render: the generator consumes a random stream in stack order, including Dynamic color draws and skips for layers that are always absent. Moving a layer can change which draws reach later choices.

Two Ways to Mint

Rejecting duplicate DNA is the default. A run that cannot find enough accepted rolls within its retry budget fails with the known count or bound; reaching that budget does not prove the entire space was exhausted. Distinct DNA records distinct selections and quantized colors, rather than guaranteeing visually different pixels.

It is not the only way. Allow repeats in the Cook dialog, or --unlimited on the command line, keeps repeated DNA, removing the uniqueness limit; identity is the token number as ERC-721 defines it. Validation, rules and bounded rule retries still apply. The weights still decide rarity: a low-weight variant stays uncommon, a layer with a low appearance chance is rarer still, and the rarest asset in the drop is the low-weight variant of a low-chance layer.

The two modes are not interchangeable for reproducibility. The same book and seed can give a different collection under each, because rejecting a duplicate spends a roll the other mode keeps — which is why set.json records uniqueDna alongside the seed.

Architecture

nfty/
├── src/
│   ├── Nfty.Core/          The engine — no UI or CLI dependency   (net10.0)
│   │   ├── Model/          Immutable domain records
│   │   ├── Formats/        ZIP + manifest IO, Validator
│   │   ├── Imaging/        Conversion, colorization, compositing, preview
│   │   ├── Generation/     RNG, rollers, DNA, rules engine, orchestrator
│   │   ├── Editing/        Layer depth, region edits, image import
│   │   ├── Output/         Set writer, dual metadata, extend loader
│   │   ├── Publish/        Export planning and AES-256-GCM sealing
│   │   └── Stats/          Rarity, and the reports both front-ends print
│   ├── Nfty.Ticket/        Roll + Menu runtime, no dependencies   (net10.0, netstandard2.1)
│   ├── Nfty.Model/         Rise: pixel art to a 3D model, glTF    (net10.0)
│   ├── Nfty.Cli/           System.CommandLine wiring              (net10.0)
│   ├── Nfty.App/           Avalonia GUI — ViewModels, Views, Themes
│   └── Nfty.Desktop/       Desktop head — window, clipboard, pickers
├── tests/                  Six xunit.v3 projects, including Ticket's .NET Standard target
│   └── fixtures/           Archives an older build wrote, and still reads
├── docs/
│   ├── manual/             The end-user manual (Material for MkDocs)
│   ├── design/archive/     A dated visual record — history, not spec
│   └── superpowers/        Design specs, newest first
├── tools/                  Demo, icons, docs capture, release build
└── nfty.sln

Generation Pipeline

NFTY generation pipeline: roll a recipe, roll each layer (a variant by weight, or absent by chance, with its color), check the rules, hash the DNA, check for a duplicate, then render and emit. Both rejections re-roll from the recipe.

Source: docs/diagrams/generation-pipeline.mmd

Both rejections re-enter at the recipe roll and share one MaxRerollsPerAsset budget per asset. Spending it throws RuleConflictException or UniqueSpaceExhaustedException, depending on the cause. Dedup runs before the render, so a collision never costs a composited canvas — and it is the step Allow repeats turns off, which is why that mode can fill any count from any book.

The DNA is a SHA-256 over the recipe id, each layer's variant id, and the quantized color of each colorized layer. Quantizing folds a continuous color space into something countable, which is what lets stats tell you how many unique DNA a book can produce before you try to mint them.

Design Principles

  • The engine is the product; the front-ends are views of it. Anything a user reads — a report, a DNA-space figure, an export summary — is rendered in Nfty.Core so the CLI and the GUI cannot disagree about it.
  • Determinism is a contract, not a side effect. Every sort that reaches an output file uses StringComparer.Ordinal; the seed hash is read little-endian rather than native-endian; anything that sums stays sequential, because floating-point addition is not associative.
  • Roll sequentially, render in parallel. The Nth asset's decisions depend on every decision before it, so rolling can never be parallel. Rendering is a pure function of a decided roll, so it parallelizes freely — and GenerateStreaming is the sequential oracle the parallel path is tested against at 1, 2, 3 and 8 threads.
  • A count says which direction it is bounded in. Exact, AtLeast, AtMost, Unknown — a product built on an under-count bounds the truth in neither direction, and a bool could not say so.
  • Nothing resamples. Every image is pixel art shown at a size unrelated to its pixel count, so the whole stack scales with nearest neighbor and import refuses a wrong-sized picture rather than scaling it.
  • Callers own images. Nfty.Core hands back live Image<Rgba32>; LoadedCookBook and GeneratedSet are IDisposable and free the whole tree.

Command Line

dotnet run --project src/Nfty.Cli -- --help
Command What it does
demo <dir> Write out the built-in demo CookBook — embedded, so it works on a copy with nothing beside it
inspect <file> Print the tree of a .cbk / .rcp / .igt / .set / .tin / .mnu, or list a .ktn. --voxel adds a partial-alpha report
validate <cbk> Report every problem found, not just the first
stats <cbk> The odds the weights imply, per Recipe and per Variant
preview <file> Render a PNG exactly as generation would — one variant, or a whole rolled stack
generate <cbk> Generate a Set
extend <cbk> <set> Grow an existing Set, recomputing rarity across all of it
menu <cbk> --out <mnu> Write a .mnu Menu: the book's weights, rules, colorization and art, flattened so a runtime host can roll and render an asset with no .cbk present
serve <mnu> Roll (--seed) or render (--ticket) one asset from a .mnu Menu, through the same render generate uses
model <png|igt|rcp> Rise a picture, Ingredient variant or seeded Recipe roll into GLB, glTF + .bin, or embedded glTF. --front N --back M fills depth on a picture or variant
export <set> Publish a cooked Set: choose what goes with it, and in what shape
new ingredient|recipe|cookbook|kitchen Build an archive from a manifest and its parts
add variant|ingredient|recipe|rule Append to an existing archive
move ingredient|recipe Reorder a Recipe's layers, or a book's recipe listing
remove rule Remove one incompatibility rule, addressed by its 1-based position
set chance|depth|variant|recipe|cookbook|voxel-ready Change a layer's absent chance, a variant's depth map or weight, a recipe's weight, book metadata; snap partial alpha
remove ingredient|variant|recipe Remove a layer, variant or recipe
share check <set> Check a Set against the community gallery's rules (canvas, assets, size, archive safety) before sharing
sheet grid <png> Read, set or clear the grid a spritesheet carries

Errors surface as a message, never a stack trace — add --verbose for the trace.

Lining Art Up

Layered art only works if the pieces register against each other, so both front-ends can composite a layer against the ones it will actually sit between:

nfty preview cat.rcp --seed alpha                     # the whole stack, one deterministic roll
nfty preview cat.rcp --seed alpha --only body,shades  # just those layers, at their real depths

Sealing

export --seal is AES-256-GCM over PBKDF2-SHA256 at 600,000 iterations, and the view-only mark is HMAC-bound to a second key derived from the same passphrase, so a third party cannot strip it. A sealed export takes its own extension (.tin) rather than being a .set whose bytes are ciphertext, because a recipient double-clicking it has to be told what it is before opening it.

There is deliberately no --passphrase flag anywhere — argv is visible to every process, lands in shell history and is captured by CI logs. --key names a source instead: env:NAME, file:PATH, stdin or prompt, and an unprefixed value is an error rather than a guess.

Note: Against the person holding the passphrase, the view-only mark buys a refusal in the product and nothing more — the format is open source. It is a lock on a door, not a wall.

Desktop Application

The same Nfty.Core engine behind an Avalonia UI: an Explorer over the open CookBook, a per-type detail pane, a Set browser over cooked output, and an Ingredient Editor with a full paint stack.

  • Two paint modes. Grayscale edits the value-map; color mode paints RGBA and saves as a Custom ingredient. Each mode carries its own saved palette, and they swap when the mode does.
  • The opacity lock is on by default and keeps every painted pixel fully opaque or fully erased, because partial alpha does not voxelize cleanly.
  • The reference panel composites sibling layers, or loose .igt files from the open Kitchen, under and over the art while you draw.
  • A gesture previews the pixels it will commit, not an outline standing in for them — the shape tools fill, and a line commits at the brush's size in the brush's ink.
  • The community gallery lists Sets other people shared. Browse from the opening screen, search with #tag, @user or a name, download one into the Set browser, and share your own from Share… with a connected GitHub account. Details are in the manual.
  • Pixel art scales with nearest neighbor. Imports must match the canvas; cooking preserves that size. Previews and the viewer's integer-scale exports keep crisp pixels without smoothing.

Performance

Measured inside the real app with Nfty.Core/Diagnostics/Perf.cs — named scopes with wall time and managed allocation, free when off, enabled by NFTY_PERF=1. It measures whole user-facing operations rather than microbenchmarks, which is why it is not BenchmarkDotNet. The figures below are historical measurements of those optimizations on the development machine and workloads shown, rather than timing guarantees for a current release.

Operation Before After What changed
Generate 200 assets @ 512px 3,020 ms 662 ms Rendering parallelized; rolling stays sequential
Write 200 assets @ 512px 2,078 ms 454 ms Per-asset writes parallelized; rarity finished first
Set browser resize (8 steps) 1,213 ms / 90 MB 342 ms / 24 MB Row chunking caches its last answer

Thumbnail decode scales with the canvas the author chose — ~0.5 ms from a 64px source, 7.1 ms from a 1000px one — so a screenful of forty large tiles was ~280 ms of frozen UI per scroll. It decodes off the UI thread now. A ZIP archive is not thread-safe, so archive extraction stays sequential and only the decode runs wide, and anything that sums stays sequential too: a different addition order is a different number, and rarity and the DNA-space count are both promises.

Development

dotnet build nfty.sln                      # build everything
dotnet test nfty.sln                       # run all tests
dotnet run --project src/Nfty.Cli -- --help
dotnet run --project src/Nfty.Desktop

Testing

dotnet test tests/Nfty.Core.Tests                             # one project
dotnet test --filter FullyQualifiedName~DnaTests              # one class
dotnet test --filter FullyQualifiedName~DnaTests.Same_selection_same_dna

Tests are named Snake_case_sentences, which is what --filter matches. Fixtures are built in memory from tiny synthetic images; there are no golden-image files, and every image assertion reads a pixel. tests/fixtures/ carries frozen archives — their value is that an older build wrote them and they still read, so they are never regenerated to make a failing test pass.

Visual Verification

Visual work is verified from a rendered frame, never from the markup:

NFTY_CAPTURE=1 NFTY_CAPTURE_DIR=./frames dotnet test tests/Nfty.App.Tests \
  --filter FullyQualifiedName~VisualCapture

…then look at the PNGs. Nearly every GUI defect this project has fixed was found that way and would have been missed by reading code. Three companion sweeps catch what a frame cannot: DarkModeContrastTests scores every text run against the surface it lands on in both themes, ThemeResourceTests proves every DynamicResource the markup names resolves in both, and MinimumWindowFitTests drives every page at the smallest window the app allows.

House Rules

  • The build is the lint. TreatWarningsAsErrors and GenerateDocumentationFile are on, so a compiler warning or an undocumented public member fails the build. NuGet advisories are audited separately; release verification also checks the publish logs for warnings and errors.
  • Generated files are committed, and the generator is the source. Themes/Icons.axaml comes from assets/icons/*.svg via python tools/icons/build.py; the demo .cbk comes from tools/demo/. Edit the generator, re-run it, commit both — a test fails if the pair disagrees.
  • Token brushes only in views. No raw hex outside Themes/Tokens.axaml, and a new color goes in both theme dictionaries.
  • Reserve the space, toggle the ink. A control appearing or disappearing must not move, resize or reflow anything around it.
  • Never edit anything in docs/design/archive/. It is a dated record; the app has moved past it by design, and a difference is not a defect.

Deployment

Releases come from a clean, verified main checkout. Set the version in Directory.Build.props, commit the intended release tree, and run both build/test and documentation gates before tagging.

  1. Run python tools/release/build.py <version> win-x64 for the four Windows ZIPs.
  2. Preserve those artifacts outside .release, then run python tools/release/build.py <version> linux-x64 for the four Linux tarballs. Each invocation deletes .release first. Verify the resolved checkout path before running it.
  3. Check every shape's extracted CLI and demo, seeded output, platform startup and complete zero-warning publish logs. Preserve the complete eight-asset set and record its hashes.
  4. Tag that committed main tree and publish all eight verified assets together with release notes. The documentation commit can precede the tag so the packaged README is current.
  • Version: <Version> in Directory.Build.props, stated once and carried by every assembly in the solution.
  • CI: ci.yml — builds and tests on Windows, audits the dependency graph for advisories separately, and re-runs the engine and CLI on Ubuntu, macOS (arm64) and Windows, because determinism is promised across architectures.
  • Library API docs: the live HTML reference covers Ticket, Core and Model. python tools/api-docs/build.py regenerates it from compiler XML and public signatures; run --check and --lint separately to verify generated pages and XML contracts.
  • Manual: the same ci.yml checks that the committed API reference and demo match their generators, builds docs/manual/ with mkdocs --strict, and runs both embedding samples. It publishes nothing: the manual is served at vaporsoft.dev/nfty/docs by the Vaporsoft site.
  • Releases: GitHub Releases — each carries both front-ends, the demo CookBook, the MIT license and the SIL Open Font License.

Troubleshooting

Note: ImageSharp must stay at 3.1.11. Version 4.0.0 requires a build-time license key (sixlabors.lic), which is account-specific and is not in this repository.

Note: The manual needs its own toolchain: pip install -r docs/requirements.txt, then mkdocs serve. docs_dir is docs/manual, not docs/, so the archived mockups and design specs stay out of the published site.

Note: GUI tests render through Avalonia's headless backend with Skia on Windows and Linux in CI. The standalone late-callback probe runs on both too. Core, CLI and Model tests also run on macOS; this does not imply a prebuilt macOS desktop release.

Note: Sealing needs AesGcm, which is a platform capability rather than a language feature. Seal.IsSupported answers for the current machine.

Resource Link
Repository github.com/corderro-artz/nfty
User manual vaporsoft.dev/nfty/docs
Latest release GitHub releases
Developer briefing CLAUDE.md · AGENTS.md
Deferred work BACKLOG.md
Design specs docs/superpowers/
CI workflow .github/workflows/ci.yml
Actions GitHub Actions
Issues GitHub issues
Pull requests GitHub pull requests
License LICENSE
Vaporsoft vaporsoft.dev

Contributing

Read CLAUDE.md first. It is the real briefing — the domain model, the file formats, and the invariants that are load-bearing but not obvious from the code. Several of its rules are the kind you would otherwise only learn by breaking something. AGENTS.md is the short version.

  1. Create a branch from main for the change.
  2. Write tests in the existing style — seeded distribution tests for rollers, exact-pixel tests for imaging, round-trip tests for archives.
  3. Run dotnet build nfty.sln and dotnet test nfty.sln before opening a pull request; both must be clean, and a warning is a failure.
  4. For any visual change, capture frames and look at them. Attach one if it helps the review.
  5. Open a pull request with enough context to review the domain, the invariants and the visual impact.

License

MIT. The interface is set in IBM Plex, bundled with the app under the SIL Open Font License — that license travels with any redistribution of the binaries, which is why every release archive carries a copy.


Copyright © 2026 Corderro Artz / Vaporsoft.

Versions

Notes

v2.12.0

14 Nov 2026On GitHub
  • The layer editor now follows the edit lock. On a locked book the Ingredient pane's pencil, Ctrl+E, double-clicking a variant and the row menu's Edit variant are disabled, so nothing can be painted and then refused at Save.
  • New Open in viewer button and row-menu item on the Ingredient pane. They work whether the book is locked or not.
  • The Ingredient pane picture is 92px so the three buttons fit under it, as on the Recipe pane.

Windows x64 and Linux x64 downloads are provided in all four existing packaging forms.

Source: 0f175a7.

Files