Things we built, and you can have.

A code reviewer that argues with itself before it touches your code.

Paste, upload or pull a repo, pick a template, and read the cleaned result beside the original or as a diff. What makes it different from a linter is the two layers around the model: a heuristic shield that reads the code before anything is sent, and a skill library you compose per run.

• Skills & Security Dome — ten capabilities toggled per run, each with the bad pattern and the fixed one side by side
• Norton heuristic shield — five local rules that match before a request leaves the machine
• Package Installer Hub — six ecosystems, four Node installers, copyable install directives
• Quality analytics — maintainability, complexity, security and readability, scored per run
• Version history, ZIP and GitHub ingest, exportable report

React 19 · runs on your own machine and your own model

The Gemini version is available now as Codecaine Gemini. The local version is coming soon.

A creative department in one window.

The largest of the three. Logo, image, product and material studios sit under one workspace with a shared brand kit, a Branding Ideas studio that cross-checks concepts for copyright collisions, and a motion prompt index for video. Thirty-plus curated design skills are pulled from GitHub and verified by AST before they run.

• Design Studios — logo, image, product and materials, one workspace
• Logo Generator — industry context, visual style, divergence sliders, vector editor
• Branding Ideas — concept generation with a copyright cross-check pass
• Brand Kit — palettes, type and assets carried across every studio
• Veo & Omni video — looping video synthesis from keyframes or a prompt
• 30+ GitHub design skills, AST-verified before execution
• Brainstorm — Idea Lab's analyzer, research and prompt creator, built in
• Agents — design, creative direction, marketing and writing agents that use Open Design's chart, graph and diagram skills

React 19 · Ollama, LM Studio or llama.cpp · ComfyUI · its own server

Runs on your own models, with no account and no Google key. Includes Branding Ideas, Brainstorm and Agents. The installer is coming soon. The Gemini version is CCO Studio Gemini.

A neural darkroom: re-render camera angles in 3D, then develop the print.

The third of the set, and the one that leans hardest into a metaphor. PortrAIt Studio treats generation as darkroom work — a crimson safelight, prints pegged to a drying wire, plates staged before they are developed. Underneath it is eight specialised studios over one latent engine: orbital camera moves in true 3D, garment and identity inpainting, dermatology-grade skin detail, scene relighting, and multi-angle storyboards.

• 6-DoF orbital camera — pan, tilt, roll and 18–200mm focal shifts with realistic sensor formats
• Garment and face swap — inpainting with auto-segmentation for wardrobe and donor identity
• Dermatology and freckles — micro-pore acutance, skin hydration and organic freckle density
• Scene Station — recontextualise a subject into neon alleys, brutalist concrete or golden hour
• Multi-angle storyboard — 4-camera rigs and 10-shot sequences with consistent identity
• Look Lab and light rigs — 3-point studio lighting positioned against physical depth maps
• Dev Studio — custom neural categories, preset injectors and reproducible recipe configs
• Vertex AI and Gemini Pro — bring your own Cloud project for zero-rate-limit batch generation

React — Gemini 3.1 Flash Image (Nano Banana 2) — Vertex AI — Red Room v6.2

The local version is coming soon. The Gemini version is PortrAIt Studio Gemini.

Frees the memory ComfyUI is still holding, before the next run fails.

ComfyUI keeps model weights resident between runs on purpose — reloading ten gigabytes per image would be absurd. The cost is that on a 12 GB card what decides whether the next generation fits is usually what is left over from the last one, and nothing surfaces that. This is a 460x780 panel that does: VRAM, system RAM, and whether ComfyUI is online and on which port, polled every four seconds.

• Auto Guardian — frees automatically when VRAM crosses 85%, with a 15-second cooldown
• Ctrl+Alt+F — a global hotkey that works mid-generation, from any window
• Free — calls ComfyUI's own /free on the detected port, trims process working sets, reloads the ComfyUI tab, and reports VRAM before and after
• Clear RAM — system memory only, file cache and working sets, GPU untouched
• Security Scan — Authenticode-checks suspicious running processes
• Port auto-detect — finds a running ComfyUI rather than asking where it is

Electron 32 · PowerShell · Windows only · MIT

Available now: v1.1.0, free, with the source public on GitHub. Also built into VIOLINET OS, which detects it as a first-party app.

Holds what an agent wants to run until a person agrees.

An agent that can run shell commands is useful exactly to the degree that it is trusted, and trust is hard to give something that acts faster than you can read. bashme takes the command before it runs, works out what it would actually do, and holds it until a person agrees — with standing rules for the routine cases so the gate does not become a thing you click through. Every decision is written to an append-only audit log. It is one codebase with two hosts: a standalone app with its own window and CLI, and a dependency-free core that VIOLINET OS embeds directly.

• Classify before rules — categories no standing rule may ever auto-approve, checked first
• Rules without wildcards — a rule cannot match a chained command, and previews what it would allow as you write it
• Append-only audit — every request, verdict and timeout, on one SQLite handle shared with its host
• HMAC plan/apply tokens — an approval authorises one command, not a session
• Outbound-only device channel — a paired phone may answer, never reach in
• Two hosts, one core — the standalone app and VIOLINET OS run identical decision code

Electron 44 · Node 24 type stripping · SQLite · no bundler

Included in VIOLINET OS under System Guard, Approvals, and available as its own app with its own window and command line. Approve from a paired phone over your home network (QR pairing) or through a relay that never opens a port on your PC. The standalone installer is coming soon.

Send a generation job to whichever GPU in the house is free.

Joins two PCs so a ComfyUI job started on one can run on the other's GPU — over Wi-Fi/LAN (the original, proven way) or a direct Ethernet cable for the fastest link between two machines side by side. Either PC can take either role: This PC, Other PC, or Both.

• Reversible roles — This PC / Other PC / Both, switched from one window
• Wi-Fi/LAN or a direct cable — same app, either transport
• 20 command buttons for connection, addresses and job dispatch
• Proven on the wire — a real generation job run on the paired GPU

Electron · Node/Python agents · Windows

A Windows installer and a portable app. The public release is coming soon.

Typed loaders, a LoRA loader that scrolls and grows with your stack, and model browsers that find duplicates in every ComfyUI folder.

One ComfyUI custom-node pack, not a fork of anything: typed checkpoint/diffusion/GGUF loaders instead of one loader with a mode dropdown, a LoRA loader that stacks up to 30 with large preview strips, trigger words wired straight into a two-box text encoder, an LLM-backed prompt enhancer and image describer, and a floating model browser with previews, CivitAI details and a duplicate finder. The latest update makes every ComfyUI model folder (controlnet, clip_vision, upscale_models, ipadapter and the rest) a category of its own, adds extra folder paths for any of them, and brings full duplicate removal to the model browser: tick the suggested files, select a range, then send them to the Recycle Bin, set them aside or delete them, with a guard that never lets you remove every copy. The LoRA loader node is bigger and easier to read, its scroll bar and mouse wheel work, the search and trigger panel are larger, and the node grows as you load more LoRAs. A ready-made image to image workflow, with a low-VRAM version, is bundled in the repo. Built from scratch by Violet Diffusion AI to replace an older pack that could not run alongside anything else because its node class names collided with other packs. This one is organized as one folder with many files by concern, the correct ComfyUI shape, and has none of those collisions.

• Violet Model / Checkpoint / Diffusion / GGUF Loaders: typed, not mode-switched
• Solar Violet LoRA Loader: up to 30 LoRAs as large preview strips with trigger words, per-LoRA strength, a working scroll bar, bigger search, and a node that grows as you add
• Violet Text Encoder: one node for positive/negative, presets, local/LM Studio/OpenCode/OpenRouter LLM enhance
• Violet Model Browser: every ComfyUI model folder as a category, extra folder paths for any of them, CivitAI details
• Duplicate finder: tick suggested, range select, Recycle Bin / set aside / delete, never removes every copy
• Image to image workflow: bundled example (and a low-VRAM version) wired through the Violet loaders, text encoder and image compare
• Network sources: browse another paired computer's models over its own ComfyUI API, nothing to install there
• Solar Prompt Enhancer & Image Describer: LLM-backed, same backend list as the text encoder

Python · ComfyUI custom node pack · vanilla JS front-end widgets · MIT

Public release 1.0.0 under the MIT licence. To install, clone it into custom_nodes, or unpack the release zip there.

Find, write, test and use the word lists your prompts draw from. 35 word lists, ten picker slots.

A wildcard is a text file with one entry per line. The Wildcard Manager scans every folder you point it at, sorts the files into categories with a picture each, rolls a file the way the nodes will, and writes new files from words, a mix of other files, your own language model or described pictures. The Wildcard Picker V2 puts ten slots on a node as cards and hands the picks to any prompt box or to the blanks of the Edit Command, where only the blank changes and the rest of the sentence stays as written. Saving never alters a library file: your version is kept apart and read first, and moving it to the trash brings the original back. A small word-list pack covers clothing, colours, materials, backgrounds, lighting, poses, expressions and outfits; every person in it is an adult.

• Wildcard Manager: scan, categories with pictures, detail drawer with a roll test and an editor, Ctrl+Alt+W
• Wildcard Picker V2: ten card slots with Choose, Roll, Random and Clear; outputs the text, the Edit Command lines and each pick
• Edit Command wildcards box: one line per blank (item, colour, material, pose, outfit and more), the sentence stays as written
• New wildcard: type words, combine files, write with your own language model, or describe pictures with a vision model
• Run this node: any Violet node that asks a language model for text can run on its own, with a fixed seed for the same text again
• Violet Wildcards word lists: 35 files, one entry per line

Python · ComfyUI custom nodes · part of Violet nodes 1.10.0

Built and part of Violet nodes 1.10.0, which is not yet released.

Turn a checkpoint into a GGUF you can load. Krea 2 included.

A 13 GB fp16 model does not fit a 12 GB card; the quantized copy is what you run. For most architectures someone has published one. For Krea 2 nobody has, and no published converter handles it, so QuantaViolet carries the architecture template itself. Point it at a .safetensors checkpoint and it reads the header first, before the long write: which architecture it is, how big each quant level will come out, whether the disk has room, and which tensors will refuse to quantize. Then Convert writes a loadable full-size GGUF, and Convert and quantize adds the Q4_K_M, Q5_K_M, Q6_K and Q8_0 levels.

• Plan first — architecture, size per level, disk space and the tensors that fall back, from the file header alone
• Convert to GGUF — a loadable full-size file, with Krea 2 detected and written as krea2
• Quantize — Q4_K_M, Q5_K_M, Q6_K and Q8_0 from the converted file
• Command line — the same two steps as a tool that prints one line of JSON per event
• Where it lives — the QuantaViolet panel in the Trainer screen of VIOLINET OS

Python · gguf · llama.cpp · inside VIOLINET OS · Apache-2.0 converter base

Built. Tested end to end on a stand-in Krea 2 checkpoint; a full-size Krea 2 file and the quantize step still need their first real run. Release is coming soon.

Sign in once. See what you own, what you can get and what is coming.

One place to get, update and buy every VIOLINET app. Sign in with your VIOLINET account and it shows what you own, what you can get and what is on the way, with the release notes for each. Downloads carry a checksum. Buy with credits or a card, and open GitHub release pages in the built-in browser without leaving the app.

• Your apps — owned, available, coming soon, and which have an update
• Release notes — read what changed before you update
• Downloads with a checksum — the file you get is the file that was published
• Buy — with credits or a card
• Built-in browser — for GitHub release pages

Electron · Windows installer

Built, with a Windows installer. The public release is coming soon.

Ask why a workflow fails, what a node does, or where a model file belongs.

A local expert for ComfyUI problems. It looks at your own install before it answers. Its memory builds itself: the whole of Comfy's documentation, about 1,800 pages, as one local text file, and the README, version and node names of every custom node pack you have installed, read again when a pack changes. Search is local, so nothing about your install leaves the computer unless you pick an online model. It reads logs and workflows when asked and never changes a file without your OK.

• Comfy's documentation — about 1,800 pages, refreshed after 14 days
• Every installed node pack — README, version, git commit and the node names it registers
• Any model — a hosted one, Ollama, LM Studio, Unsloth Studio, or a .gguf file you browse to; only models that answer are listed
• Reads before it answers — status, launch arguments, model folders, the latest log with secrets blanked, the live node list and a saved workflow
• Asks before it changes anything — Do it or Cancel

Python · SQLite full-text search · runs inside ComfyUI or on its own

Built. It installs with the Violet nodes. The public release is coming soon.

Send files, share the clipboard, show a screen, move one mouse across them.

One desk for your computers and your phone: send files, share the clipboard, show or watch a screen, move one mouse and keyboard across devices. It combines Violet Pair, LYNK and bashme. It needs no account and no cloud. Every feature starts off and is not even loaded until you plug it in; each has an Out and an In jack on each device. Pairing is by comparing a six-digit code on both devices, and the link is encrypted and signed. Modes: Minimal (the default: send files, nothing else), Recommended, Screens, ComfyUI, and your own preset.

• Pairing — compare a six-digit code on both devices
• Patch bay — an Out and an In jack per feature, per device
• Files, clipboard and notifications — in either direction
• Screens — view, share and mirror, with a notice and a Stop button for whoever is watched
• Desk map — drag the screens to match your desk; the pointer crosses the edge
• Modes — Minimal, Recommended, Screens, ComfyUI, and My preset

Electron · Node.js · Windows · 145 tests

In development. The desk layer, the page, the Windows helper, modes, screen view and the installer are built. A run on two real PCs and the phone app are still to do.

Size does matter. Resize, convert and crop a folder of images without any of them leaving the machine.

A resizer that does the tedious parts properly. It reads what a camera actually produces — RAW from Canon, Nikon and Sony, HEIC from a phone, AVIF, TIFF, animated GIF — finds the scanned border or the page edge and trims it, and writes the result to a size cap you name rather than a quality number you have to guess at. The whole application, including its Python interpreter and every package, installs into one folder you choose: no registry keys, no %APPDATA%, and one antivirus exception instead of six.

• Border detection — finds scan edges, page backgrounds and text margins, not just a solid colour
• Size cap — name a target in MB and it finds the quality that lands under it, resizing only if it must
• Smart crop — optional, local: a vision model arbitrates when geometry alone is ambiguous
• Watermark removal — marks at the edge are cropped away, marks inside the picture are reconstructed
• Upscaling — Real-ESRGAN through whichever accelerator is present: TensorRT, CUDA, DirectML or CPU
• One folder — interpreter, packages, model weights, caches and settings, all inside the install directory
• In your other apps — its 18 frames and 5 sizes are an extension for the image apps and the batch crop in SVIG

Electron 33 · Python 3.12 · Pillow / NumPy / rawpy / ONNX Runtime · Windows and macOS

Coming soon. Windows and macOS.

Angles, art styles, depth-map canvas, and an idea lab — one workspace, any model you have.

The most complete studio in the family: multi-camera angle libraries, combining artist styles, a depth-map canvas, collage and graphic labs, an idea lab for concept generation, and video. Runs on your own GPU through ComfyUI (Krea 2, Microsoft Lens, MiniMax H3 video), on NVIDIA NIM's hosted catalogue, or on Fal — Gemini is kept as one optional engine, never the default.

• Angles Library — multi-camera generation from one reference
• Art Studio — combine named artist styles into one direction
• Idea Lab — concept and prompt generation, provider-agnostic
• Collage & Graphic Labs — multi-image composition and templated graphics
• Video Studio — image-to-video with audio (MiniMax H3, local)
• Runs local (ComfyUI), hosted (NVIDIA NIM, Fal), or on Gemini as an optional engine

React · Vite · Express · ComfyUI / NVIDIA NIM / Fal · Gemini optional

Runs on your own models with no Google dependency at all. The Gemini version is ArtPi6 Gemini.

High-fidelity text reconstruction, logo replacement and pattern synthesis.

A photo-editing suite, not a generator: crop with scan-border suggestions, layered composition, ten repair modes (targeted fill, creative manifest, fix typo, replace logo, reconstruct label, enhance detail, pattern fill, inpaint, remove object, material swap), a depth-map picker, live material preview, batch processing and full undo history.

• Ten repair modes — from a targeted fill to a full material swap
• Depth-map picker — selection tool aware of scene depth
• Layered composition — placed assets with live material preview
• Batch processing — the same repair across many files at once
• Timeline & history inspector — full undo, not just the last step

React · Gemini image models (Flash Image, Imagen 4)

The local version is coming soon. The Gemini version is GenFix Gemini.

Retouch portraits live on your own machine, then apply the look to the whole shoot.

A portrait retouching studio that runs locally: no account, no cloud, no API key. Sliders move a WebGL2 renderer, so a preview re-renders in about a millisecond. Pick a look from the category preset gallery, fix the background, edit one photo and apply it to the whole folder. Face shaping follows the head pose, so a turned face is reshaped on the right side of the face, not flattened.

• Live retouch — skin smoothing with texture kept, blemish removal, even tone, eyes, lips, teeth, dark circles, face, jaw, chin, nose and smile shaping, hair colour, relight
• Preset gallery — twelve looks in four categories (Everyday, Glam, Light & colour, Face & smile), each previewed on your own photo
• Background tools — blur, violet or custom gradient, solid colour, your own image, or a transparent cut-out, matted locally by MODNet
• Batch — add a whole shoot, edit one photo, apply the look to all, export the folder
• Undo, redo, before and after, and export size, format and quality
• Optional heavy jobs through your own ComfyUI — upscale, generative relight, polish and face swap

Electron · React · WebGL2 · MediaPipe · MODNet · runs offline

Runs locally with no account or API key; the default build contains no Google SDK. The Gemini build is LoumiNova AI Gemini.

Turn a picture, a pile of references or a half-idea into prompts that work.

The brainstorm module from ArtPi6, as its own app. It analyzes one image or several, researches references, generates and merges ideas, and writes the final prompt for the model you are using, with LoRA triggers and camera, lighting and style choices. It is not tied to one provider: the thinking model can be Ollama, LM Studio, OmniRoute, OpenRouter, OpenAI or NVIDIA NIM, and images go to your own ComfyUI. The same module is the Brainstorm tab inside CCO Studio and VIOLINET OS.

• Analyzer — single image, combo or text only, with divergence and chaos sliders
• Research — reference search, and reference images carried into the prompt
• Prompt Creator — concept or reverse mode, target model, LoRA keywords, lighting and camera
• History and Favorites — semantic search over past ideas
• Any provider — local first; hosted models are optional

React 19 · Ollama, LM Studio, OmniRoute, OpenRouter, OpenAI, NVIDIA NIM · ComfyUI

Included in CCO Studio and in VIOLINET OS as Brainstorm. A standalone installer is coming soon.

One image app: ComfyUI when you want nodes, the Violet Engine when you do not.

A desktop image app that runs ComfyUI and its own built-in engine, the Violet Engine, side by side, with the Violet node pack for the standard graphs. The Studio lists 38 models, from Z-Image and Flux to Klein, ERNIE and HiDream, each tagged with the engine that can run it. It has eleven pages (Studio, Generate, Flux, SD, Edit & Upscale, PiD, Browse, Workflows, Discovery, VioletBot and Settings) and its own Python, locked to the install folder, so setup never touches the system Python.

• Studio — pick one of 38 models, a speed (Fast, Balanced or Quality), a size and write the prompt
• Two engines — ComfyUI, managed for you with the Violet nodes, and the Violet Engine, which needs no node graph
• Flux page — Flux 1, Flux 2, Krea, Klein 4B and 9B, with BF16, GGUF and FP8 choices and the files each needs
• Edit & Upscale — image to image, upscale and the edit models in one place
• Own runtime — its Python lives in the install folder
• Violet Load Image — crop, HEIC and paste when the node pack is present

Electron · React · FastAPI · ComfyUI

Built. A Windows installer is coming soon.

One model browser that looks and works the same in every VIOLINET app.

A scoped CivitAI browser, a single file with no build step and no dependencies. Every VIOLINET app carries it, so finding a LoRA or checkpoint is the same experience everywhere. It uses the CivitAI Red instance by default; the Blue instance is an off-by-default setting.

• Scoped search — a curated view rather than the open site
• Same everywhere — one component inside every app
• Your key, if needed — public models need none; downloads and gated models do

One custom element · no dependencies

Built into every VIOLINET app. Not a separate download.

Plugins and skills for every workflow, one click from VIOLINET OS.

A storefront for 584 plugins from Anthropic, Cursor and partners, plus the Violet skills written by VIOLINET Tech. Every skill has three buttons: View on GitHub, Download to PC and Add to VIOLINET OS. Skills can carry their own cover and banner pictures, and you can upload your own. Each plugin installs from its own repository, on your click.

• Storefront — hero, shelves, filters and search across every plugin
• Violet skills — View on GitHub, Download to PC, Add to VIOLINET OS
• Covers and banners — from the skill folder, or upload your own
• Connectors — hand a plugin's connectors straight to the Connectors tab

Dependency-free page · the same code on the web and inside VIOLINET OS

Inside VIOLINET OS under Skills, Plugin marketplace. Community skill submissions, with a profile page for each author, are coming soon.

Sort, crop and rename a whole folder of pictures, on your own computer.

SVIG is a photo manager for the pictures you make and keep. Rate and cull from the keyboard, search by name, tag or the prompt stored inside an AI picture, find duplicates, and fix a whole batch at once: crop a hundred pictures to Instagram Post or YouTube Thumbnail size, or rename them from a pattern after a preview. Your originals are never changed unless you say so. The same library opens on your phone by QR code.

• Bulk crop — pick one of 18 frames or 5 sizes, or type your own; the cut keeps what stands out, and flat borders can be trimmed first
• Bulk rename — build names from the old name, a number, the date, the size and the folder, see every new name first, and nothing changes if two would clash
• Rate and cull — stars, picks and rejects at full screen, with the keyboard
• Search — names, tags, model, LoRA, seed and the prompt stored in AI pictures
• Duplicates — exact copies and look-alikes, with the best one kept
• Metadata — clean it, write it, or make a picture read like a phone photo
• Phone access — open the library on your phone by QR code to view and rate
• Your account — sign in with your VIOLINET Tech account

Desktop app · Windows · everything it needs is inside the installer

Coming soon. Windows first.