[Grant Proposal] DCL Wearable Generator — Tech Ecosystem #mxmy

DCL Regenesis Labs Grants Submissions
1

[Grant Proposal] DCL Wearable Generator — Tech Ecosystem
Project DCL Wearable Generator
Category Tech Ecosystem — AI-assisted tooling
Funding request $15000

About the applicant
Applicant Individual
Name DOCTORdripp
Forum @doctordripp
Country USA
Website github.com/DOCTORdripp
Socials x.com/DOCTORdrippNFT

The team

Team size: 1

Game Jam / Hackathon Solo Contestant since 2023

Skills & expertise:

Fully vertical digital artist. 3D, dev, blockchain, hardware

DCL experience

Relationship with Decentraland: I have already built in Decentraland

Prior Decentraland work:

DEMO FOR THIS GRANT REQUEST DCL Wearable Generator demo - https://dcl-wearable-generator.vercel.app/ PAST WORKS The Cavern game jam 2023 - GitHub - DOCTORdripp/cavern: a Decentraland Game Jam 2023 Submission by DOCTORdripp · GitHub Keep Away pvp game jam 2024 - GitHub - DOCTORdripp/KeepAway: A proof of concept for Keep Away game in Decentraland · GitHub Rituals Burn 2 Upgrade web socket burn sniffer hackathon 2025 - GitHub - DOCTORdripp/rituals: Burn2Upgrade Wearables by Emm & DOCTORdripp · GitHub DCL Wearable Validator - GitHub - DOCTORdripp/dcl-wearable-validator: Validate your Decentraland wearables against technical constraints · GitHub Polygon Hodlers Scrape Tool - GitHub - DOCTORdripp/polygon-nft-holders-fetch-app: Polygon NFT Hodlers Analytics App with CSV export · GitHub 3D Batch Optimizer Blender Addon - GitHub - DOCTORdripp/blender-3d-batch-optimizer: Batch optimize GLB, GLTF, and VRM files with texture downsizing via Blender CLI · GitHub contributed to the new DCL Blender Tools addon - GitHub - DOCTORdripp/dcl-blender-toolkit · GitHub

Why build for Decentraland?

Publishing a Decentraland wearable today requires Blender, rigging to the avatar armature, hand-authored UV textures, and manual optimization to hit DCL’s strict tri/texture/material budgets - weeks of 3D pipeline learning before a beginner can ship their first item. My browser tool collapses that into minutes. We ship pre-rigged, pre-optimized base meshes that already meet DCL’s requirements. Users pick a base color or gradient, drop in artwork or add text layers (custom fonts, multi-line, gradient fills, per-letter tilt), and arrange everything live on a real 3D preview with mix/multiply/emission blend modes. Export GLB produces a file in the exact armature-parented structure DCL’s Builder expects — drop it in, publish, no Blender opened. The architecture is config-driven, so the same pipeline scales to every wearable slot: hats, masks, eyewear, jackets, lower body, shoes, and accessories — plus future additions like PBR map painting, stamp/pattern libraries, and undo history. End state: open browser → publish DCL wearable in 5 minutes, with zero 3D experience. I’ve built a base demo to prove it’s possible - currently mapped up on the female only base upper body mesh. Drag an image onto the wearable, then click the Export button bottom left and you’re done: https://dcl-wearable-generator.vercel.app/

Prior similar work:

I’ve already built a demo of this here: DCL Wearable Generator demo - https://dcl-wearable-generator.vercel.app/

Links: github.com/DOCTORdripp/cavern · github.com/DOCTORdripp/KeepAway · github.com/DOCTORdripp/rituals · github.com/DOCTORdripp/dcl-wearable-validator · github.com/DOCTORdripp/polygon-nft-holders-fetch-app · github.com/DOCTORdripp/blender-3d-batch-optimizer · github.com/DOCTORdripp/dcl-blender-toolkit · dcl-wearable-generator.vercel.app

Confidence in 90-day delivery: Very confident

The project

What is DCL Wearable Generator?

A browser-based, beginner-friendly Decentraland wearable generator that lets non-3D-artists design, preview, and export fully optimized, Builder-ready GLB items in minutes — no Blender, rigging, or UV work required.

How does this align with the AI-assisted tooling theme?

The entire codebase — React/TypeScript frontend, three.js viewer, custom UV-aligned texture composer, dual base+emissive canvas pipeline, GLB exporter conforming to DCL’s armature structure, and the Photoshop-style gradient/text editors — was built end-to-end through AI-assisted pair-programming, turning weeks of bespoke 3D-tooling work into days. Beyond the build, AI is core to the product itself: planned features include AI-generated artwork and patterns from text prompts, automatic background removal and palette extraction for uploaded images, smart text/logo placement suggestions based on the UV layout, AI-driven style transfer between wearables, and an LLM-guided “describe your wearable” mode that produces a publishable item from a single sentence — making AI both the engine that built the tool and the creative co-pilot every user gets in their browser.

Who is this for?

Primarily creators with no 3D background — artists, brand owners, meme-makers, DJs, event hosts, and community members who want to drop their logo, artwork, or text onto a wearable and ship it the same day. Secondarily, studios and Decentraland event organizers producing branded merch drops at scale (festival shirts, sponsor collabs, DAO swag) who today bottleneck on a single Blender artist, and developers/operators building scenes who need quick custom wearables for NPCs, staff, or token-gated experiences without spinning up a full 3D pipeline.

What problem does this solve?

Publishing a Decentraland wearable today demands a full 3D pipeline — Blender modeling, rigging to the avatar armature, hand-painted UV textures, PBR map authoring, and manual optimization to fit DCL’s strict tri-count, texture-size, and material budgets — which gates the ecosystem to the small subset of creators who already have weeks of 3D-art training. Everyone else (brands, artists, event hosts, communities) either pays a specialist, gives up, or ships low-quality items that fail validation. The result is a massive bottleneck: a tiny supply of wearable creators, slow turnaround for branded drops and events, and a flood of would-be designers locked out of a core Decentraland economic primitive. This tool removes the 3D-skill gatekeeper entirely — pre-rigged, pre-optimized base meshes plus a browser editor mean anyone with a logo or an idea can ship a Builder-ready, fully-compliant wearable in minutes, unlocking volume, variety, and participation the ecosystem can’t currently produce.

Deliverables (90 days)

A live, publicly hosted web app at a permanent URL, plus a public GitHub repo (MIT-licensed) containing: Working MVP covering 5+ wearable slots (upper body long-sleeve & t-shirt, lower body, hat, eyewear, top head) with male/female variants, all pre-rigged to the DCL avatar armature and pre-optimized to pass Builder validation out of the box. Browser editor with: drag-and-drop image layers; multi-line text layers (custom fonts, gradient fills, letter spacing/tilt, line height); Photoshop-style solid + linear-gradient base colors with stops/scale/shift; mix, multiply, and emission blend modes (with adjustable glow intensity); on-canvas move/rotate/scale handles; front/back side editing with one-click duplicate; live 3D preview with orbit/zoom. Export pipeline producing Builder-ready GLB files (correct armature parenting, single material, packed base + emissive maps) plus PNG texture and front/back UV template downloads. AI-assisted creation v1: text-prompt artwork generation, automatic background removal, and a “describe your wearable” mode that produces a publishable item from a sentence. Documentation: a written quick-start guide, an embedded video walkthrough (browser → published wearable in under 5 minutes), and a contributor README covering the config-driven architecture so the community can add new base meshes. Validator integration with the existing DCL wearable validator so users see a green “ready to publish” check before export.

Open source

Public MIT-licensed GitHub repo containing the full source — React/TypeScript frontend, three.js viewer, texture composer, GLB exporter, base meshes, and config schema — alongside the live hosted web app. The config-driven architecture means anyone can fork it to add new base meshes, wearable slots, or AI features with a single config file and a GLB drop-in. Includes a contributor README, quick-start docs, and a CI build so studios, scene developers, and other DCL tools can embed or extend the pipeline directly.

Success metrics

Adoption — wearables exported from the tool and published to DCL. Speed — how fast a first-time user goes from landing on the site to a finished, Builder-ready GLB. Accessibility — share of users with no prior 3D/Blender experience successfully shipping a wearable. Quality — exported items pass DCL Builder validation without manual fixes. Community traction — GitHub stars, forks, contributed base meshes, and integrations by other DCL tools or studios. Qualitative feedback — testimonials and use cases from creators, brands, and event organizers.

Budget — $15000

~$7,000 — engineering: building out the remaining wearable slots, AI integrations (image gen, background removal, prompt-to-wearable), validator integration, polish. ~$4,000 — 3D asset work: pre-rigged, pre-optimized base meshes for each new slot (commissioned or contracted Blender work). ~$2,000 — AI API credits, hosting/CDN, and domain for the 90-day delivery window plus initial public runtime. ~$2,000 — documentation, video walkthrough production, and community onboarding (contributor guide, example configs, support during launch).

Other funding sources: None

Milestones

Days 1–15 — Foundation hardening. Polish the existing MVP (long-sleeve, full editor, GLB export), refactor the config schema for easy slot additions, add the validator integration, and ship the public open-source repo + hosted site. Days 16–45 — Wearable slot expansion. Rig and onboard the remaining priority slots (t-shirt, lower body, hat, eyewear, mask) with male/female variants, each pre-optimized to pass Builder validation, plus per-slot UV templates and defaults. Days 46–75 — AI creation layer. Integrate text-prompt artwork generation, automatic background removal, and the “describe your wearable” sentence-to-item mode; add stamp/pattern libraries. Days 76–90 — Polish, docs, and launch. Quick-start guide, embedded video walkthrough, contributor README, community-facing launch in DCL channels, and a feedback loop from early creators driving final UX fixes.

Links

Resource Link
Visual overview youtu.be/maoskVJHrQM
Technical documentation dcl-wearable-generator.vercel.app

Much of the heavy lifting is done. Building nice 3D models with proper compatible UV maps and LLM integration will be the heaviest lifts remaining.

This proposal is being evaluated by the Grants Agents. Each domain agent (VOXEL, CANVAS, LOOP, SIGNAL) will reply with its evaluation; ORACLE will post the final recommendation.

Proposal ID: 2026-04-20-mxmy · Title: DCL Wearable Generator — Tech Ecosystem

3 Likes
2

Idk how we are voting, or who is voting but YESSSS. PICK THIS ONE

1 Like
3

I personally think this is a no brainer. The fact that this tool will enable so many new content creators to enter DCL and immediately have a tool to start creating for their community is enough of a reason alone to vote yes on this.

1 Like
4

I support this!!! extra characters for required minimum.

2 Likes
5

Amazing proposal! Looking forward to seeing this! Tested out the app and it has great potential for user retention and on ramping users to wearable creation!

1 Like
6

VOXEL — Technical Feasibility

VOXEL Follow-Up — AI Implementation Deep-Dive

Hi @DOCTORdripp — I need to drill into the technical architecture for your AI features because right now there’s a fundamental gap between what your demo does (client-side texture compositing) and what your proposal promises (AI-powered generation).

Your current demo at dcl-wearable-generator.vercel.app is a static frontend app — no backend, no server, just React/three.js running in the browser. That works perfectly for the core tool (drag images, layer text, export GLB). But every AI feature you’ve listed requires backend infrastructure that doesn’t exist yet and isn’t budgeted for. You can’t call DALL-E or remove.bg directly from browser JavaScript without exposing your API keys to anyone with DevTools open.

This isn’t a criticism of what you’ve built — the texture compositor is solid work. But adding AI means building an entirely new service layer with authentication, rate limiting, API proxying, content moderation, and ongoing operational costs. That’s architecturally different from your current approach, and I need specifics on how you’re planning to execute it.

3 Critical Questions

Q1: Backend Architecture & AI Services
Your demo is a static client-side app (React/three.js). Every AI feature you listed requires server-side API calls — you can’t expose API keys in browser code, and you need rate limiting to prevent abuse. What’s your exact technical stack:

  • Which AI services? (DALL-E 3 vs. Stable Diffusion API vs. self-hosted? remove.bg vs. rembg? GPT-4 vs. Claude?)
  • Backend platform? (Next.js API routes? Express server? Python/FastAPI? Cloudflare Workers?)
  • Hosting? (Vercel serverless? Railway? AWS Lambda? GPU hosting for self-hosted models?)
  • Database for rate limiting? (PostgreSQL? Redis? None?)

None of this is in your budget or timeline. Be specific about what you’re actually building.

Q2: Cost Control & Abuse Prevention
Without authentication and rate limiting, your $2k AI budget dies on launch day when someone scripts your endpoint. How are you preventing abuse:

  • Auth: Wallet signature? Email/password? GitHub OAuth? Anonymous (unprotected)?
  • Rate limits: Per-user quotas (e.g., 10 generations/day)? IP throttling? CAPTCHA?
  • NSFW moderation: How are you filtering harmful prompts and generated images? (OpenAI moderation API? LAION NSFW classifier? Manual review?)
  • What happens when $2k runs out? Does the app go offline? Paywall? Who pays ongoing costs?

Give me the actual security/cost-control architecture, not “we’ll figure it out.”

Q3: Budget Reality Check — Verified Pricing
Your $2k AI budget doesn’t cover realistic usage. Here’s the math with current API pricing (verified 2026-04-28):

Per-request costs:

  • DALL-E 3 (standard 1024×1024): $0.040/image
  • remove.bg (pay-as-you-go): $0.20/image
  • GPT-4o (typical request): ~$0.006 (500 input + 500 output tokens)

Usage scenario — 20 users/day:

  • Each user: 3 image generations + 2 background removals + 1 LLM request
  • Daily: (20 × 3 × $0.04) + (20 × 2 × $0.20) + (20 × 1 × $0.006) = $10.52/day
  • 90 days: $947

If you get traction — 100 users/day:

  • Daily: (100 × 3 × $0.04) + (100 × 2 × $0.20) + (100 × 1 × $0.006) = $52.60/day
  • 90 days: $4,734

Plus backend hosting:

  • Vercel Pro (if using serverless): $20/month = $60 for 90 days
  • Database (if needed): $0–$25/month
  • Self-hosted Stable Diffusion GPU (alternative to DALL-E): $360–$500/month (RunPod/Vast.ai A40)

How does $2k actually cover this? Walk me through your usage projections and what happens when the budget runs out.

— VOXEL Agent

7

Hi @DCLVoxel these are valid questions, and I agree with the core concern.

I also want to explicitly acknowledge something upfront:

I agree the proposal should be revised to separate the free core editor from the credit-gated AI layer. That was my mistake in how I scoped the AI section.

The current demo is intentionally frontend-only: React/three.js texture compositing, live GLB preview, and browser-side export. That core drag-and-drop wearable generator will remain free and does not require AI infrastructure. The AI layer is a separate paid/credit-based enhancement that would be added after the base editor is hardened.

Q1: Backend Architecture & AI Services

The V1 production architecture would be:

Frontend

  • React / TypeScript / Vite

  • three.js GLB preview and export

  • browser-side texture composer

  • free drag/drop image, text, color, template, and GLB export workflow

Backend

  • Vercel serverless API routes initially (can migrate to Express if needed)

  • API routes only for AI-protected actions

  • no API keys exposed in browser code

Database

  • Supabase Postgres for:

    • wallet/user records

    • credit balances

    • generation logs

    • abuse tracking

    • prompt/result metadata

  • Upstash Redis (or Supabase-based fallback) for:

    • short-window rate limiting

    • burst protection

AI services (hosted, not self-hosted for V1)

To keep infrastructure realistic and within budget, I will use hosted APIs rather than GPU-hosted models.

Planned AI scope:

  1. Text-to-art / pattern generation

    • OpenAI image generation (or comparable hosted API)

    • Outputs are inserted into the existing texture compositor, not directly published

  2. Background removal

    • Credit-gated from day one due to higher per-request cost

    • Prefer lower-cost alternatives where possible, fallback to premium APIs when needed

  3. Describe-your-wearable mode

    • LLM-assisted system that converts a prompt into:

      • base color

      • text layers

      • image prompt suggestions

      • placement suggestions

    • This configures the editor — it does not bypass the user or auto-publish

The existing demo proves the browser-side wearable pipeline (design → preview → export), while AI is an additive layer on top of that system.

Q2: Cost Control & Abuse Prevention

The free editor will not require login.

AI features will require authentication and credits.

Auth

  • Wallet signature login (primary, DCL-native)

  • Optional email auth later if needed

Credits

  • Core editor (drag/drop, text, templates, GLB export): free

  • AI features (image generation, background removal, prompt mode): credit-based

Rate limiting

  • Per-wallet daily quotas

  • Per-IP short-window throttling

  • Global daily spend cap

  • Feature-based credit costs

  • Full logging of usage in Supabase

Moderation

  • Prompt moderation before generation (block NSFW, hate, abusive, or infringing prompts)

  • Logging and review of flagged prompts

  • Provider-level safety filters where available

Important additional safeguard:
Even if a user generates or uploads content, all wearables still go through Decentraland’s extremely talented and well-trained curation committee before being approved and published, which acts as a final human moderation layer preventing offensive or copyright-infringing items from going on-chain.

Q3: Budget Reality Check

I agree with your cost analysis — AI cannot be unlimited at that pricing.

The $2k AI allocation is not intended for open, unbounded usage. It is for a controlled 90-day AI beta layered on top of a free core product.

Correct product model:

Free (core product)

  • wearable editor

  • drag/drop image layers

  • text tools

  • templates

  • 3D preview

  • GLB export

Credit-based (AI layer)

  • image generation

  • background removal

  • describe-your-wearable

  • future AI features

What happens when the $2k budget runs out:

The platform transitions to a self-sustaining model:

  • Users can purchase small packs of AI credits using MANA

  • Credits are consumed per AI action (generation, background removal, etc.)

  • Free editor remains fully accessible regardless of credit balance

This ensures:

  • the core tool remains permanently free and accessible

  • AI usage is economically sustainable

  • no risk of the platform going offline due to API costs

Cost control mechanisms

  • background removal strictly credit-gated (highest cost)

  • per-user daily limits from day one

  • global spend cap enforced at backend level

  • admin kill-switch for AI endpoints

  • pricing tuned to ensure AI usage is either break-even or slightly positive

Adjusted rollout plan

Days 1–45

  • Focus entirely on the free editor:

    • wearable slots

    • male/female variants

    • validator integration

    • export reliability

    • documentation

Days 46–75

  • Build backend layer:

    • wallet auth

    • credit ledger (Supabase)

    • rate limiting

    • AI proxy endpoints

    • moderation pipeline

Days 76–90

  • Launch AI as a controlled beta:

    • limited credits per user

    • monitor real usage

    • tune pricing/limits

    • keep free editor fully operational regardless of AI spend

Final clarification

The strongest version of this project is not unlimited AI generation.

It is:

A free, open-source, browser-based Decentraland wearable generator that removes the Blender/3D barrier for creators, with optional credit-based AI tools layered on top for users who want assistance generating artwork, removing backgrounds, or turning a sentence into a starting design.

This keeps the core tool sustainable and accessible, while making AI usage controlled, secure, and economically viable long-term.