TrueForm

• 

  Trueform’s landing interface, featuring the Trueform logo and the prompt input where users describe the image they want to generate.

• 

  Trueform’s interface displaying the user prompt, extracted requirements, and generated AI image together.

Inspiration

AI image generators can create incredibly realistic images, but one problem still remains: how do we know if the generated image actually followed everything we asked for?

A single prompt can contain many requirements — objects, colors, quantities, lighting, environment, and style. Usually, all of these are treated as one block of text, making it difficult to track what was actually requested.

That is where "Trueform" came from.

I wanted to build a system that connects the user's requirements to the generated image instead of treating generation as a simple prompt → image process.

Generate it. Track it. Prove it.

What I Built

Trueform is a prototype for requirement-aware AI image generation.

The current workflow is:

Prompt → Requirement Extraction → Image Generation → Requirement Tracking

For example, if a user asks for “a matte black perfume bottle with exactly three white flowers and soft studio lighting,” Trueform separates these into individual requirements and displays them alongside the generated image.

The current prototype focuses on building this foundation. Automated visual PASS/FAIL verification is the next stage.

How I Built It

I built the project from the frontend to the AI pipeline as a solo developer.

HTML, CSS & JavaScript** — frontend Rust + Axum + Tokio** — backend and API ComfyUI + Stable Diffusion 1.5** — local image generation JSON / REST API** — communication between the components Git & GitHub** — version control and milestones

The core pipeline is:

Text Prompt ↓ Rust Backend ↓ Requirement Extraction ↓ ComfyUI + Stable Diffusion ↓ Generated Image ↓ Requirements + Result ↓ Frontend

Instead of using a paid cloud image-generation API, I integrated ComfyUI with Stable Diffusion locally and connected it to my Rust backend.

What I Learned

The biggest lesson was that an AI application is much more than the model itself.

I had to connect and debug the frontend, backend, APIs, image-generation workflow, and local GPU pipeline as one system. Along the way, I learned Rust backend development, asynchronous processing, JSON serialization, API integration, ComfyUI workflows, and local AI inference.

Building everything myself also taught me how much engineering is involved in turning an AI idea into an actual working application.

Challenges

The hardest part was getting the entire pipeline to communicate reliably.

I dealt with issues involving API communication, ComfyUI workflows, file paths, frontend caching, image retrieval, and displaying the generated result correctly.

With limited hackathon time, I had to prioritize the core idea rather than trying to build every planned feature.

That meant getting requirement extraction, local generation, and requirement tracking working first.

What's Next

The next step is multimodal verification.

Instead of only tracking what the user requested, Trueform will eventually analyze the generated image and compare it against each requirement.

For example:

text Exactly three white flowers ↓ Image Analysis ↓ PASS / FAIL / UNCERTAIN

That would turn Trueform from a system that understands what you asked for into one that can also check how well the AI actually followed it.

That's the direction I'm taking Trueform:

From generating images to making AI outputs measurable and verifiable. on

Built With

• axum
• comfyui
• css
• git
• github
• html
• javascript
• rust
• stable-diffusion-1.5
• tokio