Mrinal Parida

Posted on May 24 • Edited on May 29

🌸 BLOOM : Gemma 4 Inside. Limits Outside.

#devchallenge #gemmachallenge #gemma #ai

Gemma 4 Challenge: Build With Gemma 4 Submission

The Creative Revolution Has Bloomed

Meet BLOOM, the ultimate playground for individual creators, solopreneurs, inventors, and visionary thinkers who are tired of standard, boring AI responses and generic outputs. BLOOM is an organic digital conservatory designed to smash together completely unrelated worlds, text, and images to grow ideas that have never existed before.

BLOOM is an organic digital conservatory where completely unrelated ideas collide and grow on their own. Words, visuals, concepts that should never meet are planted together on purpose. You don’t write prompts, you plant sparks. The result is raw innovation. Ideas mutate, cross pollinate, and evolve into original, production ready concepts you will not find anywhere else.

Whether you are building a startup, designing the next viral brand, or exploring wild creative directions, BLOOM pushes you beyond templates and into true invention.

🌐 Launch the Lab and start experimenting

🌸 Launch the Lab: https://trybloomlabs.vercel.app/

NOTE:

Please allow 1 to 4 minutes for the engine to analyze your problem matrices, sprout its reasoning and cultivate your breakthrough. Hang tight to see the magic bloom!
Thank you for your patience!

🌸 Explore the Codebase: https://github.com/pmrinal2005/BLOOM.git

🌸 Watch the Demo: https://youtu.be/2nzXjrcIF18?si=PWce5YJMGGDX_dct

🌟Mind-Bending Features & Capabilities

🌱 Multi Modal Seed Altar: Drop in your high-stakes problem text or image on one side, then plant a completely wild, disconnected visual inspiration matrix on the other side to spark cross-pollination between completely separate realities that would never normally meet. Your business challenge meets abstract art. Your data problem meets nature photography. The collisions are incredible!

🌸 Living Botanical Architecture: Watch your boring data literally transform into a living digital ecosystem right in front of you where main structural flowers bloom to represent your core entities and their glowing petals represent distinct sub-entities. The whole thing moves and breathes like an actual garden, except this garden contains your breakthrough ideas waiting to be discovered.

⚡Interactive Synaptic Grafting: This is my favorite part! You can drag and drop to physically wire two different flowers together to force an instant conceptual collision between ideas that have nothing to do with each other, letting you watch in real time as it thinks, processes, and breeds totally out of the box breakthroughs.

🔬Ecosystem Manipulation: You have total control over this conceptual garden. You can delete specific petals to strip away sub-entities you don't need anymore or graft entire flowers together and watch them cross-pollinate right before your eyes, giving rise to entirely new mutant flowers in real time representing hybrid concepts nobody has ever explored. You're literally gardening with ideas.

🧠 Dual Engine Growth Modes: Toggle between two specialized cognitive states, utilizing Focused Mode for razor-sharp engineering logic and precision problem solving or unleashing Divergent Mode to intentionally force the model to look past obvious logic and engage its fringe specialists.

👁️The Core Observatory: This pulls back the curtain on AI's famous black box. A live analysis panel shows you the raw reasoning stream of the model in real time. You watch exactly how it weaves your inputs together, how it makes unexpected connections, and how breakthrough ideas actually form inside the machine. Total transparency into artificial thinking.

📊 The Ultimate Innovation Harvest: Step into the most beautiful workspace you've ever seen. Fully realized blueprints are automatically organized into Core Insights, Future Scenarios, and Flow Analysis. Every single cross-pollination sequence the model analyzes gets documented perfectly. Nothing falls through the cracks. Your genius is captured and ready to execute.

🎨 Adaptive Aesthetic Ecosystem: Designed to fit your exact creative workflow seamlessly with full native support for both ultra-clean Light Mode when you want minimalist focus and switch to futuristic neon-glassmorphic Dark Mode when you want that cyberpunk innovation energy.

🤖 Pure Machine Imagination: Every single connection, hybrid concept, and radical blueprint is thought up entirely from scratch by the core intelligence engine (A highly efficient Gemma-4-26B-A4B-IT model designed for high-throughput, advanced reasoning), ensuring true originality with zero human bias.

🧠 Driven by Google Gemma 4 26B MoE A4B

To build a true conceptual accelerator, generic large language models(LLMs) were out of the question because they are algorithmically tuned to smooth out creative friction, averaging down wild, disruptive ideas into predictable, homogenized patterns. But BLOOM doesn't deal in the predictable. It required an engine capable of sustaining extreme conceptual tension without breaking structural integrity.

That is why I'm proud to announce that BLOOM is orchestrated _by the _state-of-the-art 🧠 Google Gemma 4 26B Mixture-of-Experts (MoE) A4B model, natively routed through the ultra-low-latency Google AI Studio API.

Here is how this architectural powerhouse is transforming raw data into a thriving garden of actionable intelligence:

1. Isolating the Spark (128-Expert Architecture):
Traditional architectures suffer from cognitive bleeding, mixing too many complex ideas, and the output dilutes into generic prose. Gemma 4 26B MoE changes the game with an internal fabric of 128 highly specialized virtual experts. It isolates fundamentally divergent domains into separate, parallel cognitive compartments, allowing fragile, highly unique ideas to mature fully before synthesis occurs.
2. The 8-Expert Synergy (Cross-Domain Cross-Pollination): Real innovation happens at the intersection of disciplines. By dynamically activating an optimal array of 8 precise specialists alongside a foundational shared routing layer, Gemma 4 26B MoE allows entirely disparate fields like biometric architectures, complex legal frameworks, fluid dynamics, raw computer vision, etc to directly cross-pollinate directly on a single token stream.
🗺️ 3. Massive 256K Context Window: Deep ideation requires a massive data runway. Our pipeline doesn't just read text, it also visually deconstructs architecture. Gemma 4 provides a 256K context window, Bloom can concurrently ingest intricate visual matrix structures and long-form textual datasets. It maintains absolute global coherence across deep conversation histories, ensuring your generated concept map remains stable and logically sound from root to leaf.

🏗️ Architectural Breakdown: How the Code Leverages the Model

The orchestrator functions as a highly structured pipeline designed to harness the model’s multimodal and reasoning capabilities. The architecture leverages these strengths in several distinct ways:

Dynamic Multi-Parametric Injection: The normalizeModelParams function blends the user-defined modelParams with an algorithmic creativityLevel. This directly influences the generation engine's behavior (temperature, topP, topK), allowing the architecture to toggle seamlessly between localized, hyper-focused solutions and expansive, cross-domain analogies.

function normalizeModelParams(modelParams: ModelParams, creativityLevel: number): NormalizedModelParams {
  const creativityTemperature = 0.4 + ((creativityLevel - 0.3) / 0.7) * 1.2;
  const blendedTemp = creativityTemperature * 0.6 + Number(modelParams.temperature) * 0.4;
  const temperature = Number.isFinite(blendedTemp) ? Math.min(Math.max(blendedTemp, 0.01), 1.99) : 0.8;
  const creativityTopP = 0.7 + ((creativityLevel - 0.3) / 0.7) * 0.25;
  const rawTopP = Number(modelParams.top_p);
  const blendedTopP = creativityTopP * 0.5 + rawTopP * 0.5;
  const topP = Number.isFinite(blendedTopP) ? Math.min(Math.max(blendedTopP, 0.01), 1.0) : 0.9;
  const topK = Number.isFinite(Number(modelParams.top_k)) ? Math.max(1, Math.floor(Number(modelParams.top_k))) : 40;
  return { temperature, topP, topK };
}

Multimodal Fusion Routing: The buildMultimodalParts function acts as a structural parser. It ingest dual-stream image matrices (problemUploadUrl and a sliced array of inspirationUrls), converts them into base64 inline data packets, and appends architectural analysis prompts. This forces the model to run joint textual-visual cross-referencing over design patterns, color systems, and spatial arrangements.

async function buildMultimodalParts(
  payload: GenerationPayload, textPrompt: string
): Promise<Array<{ text: string } | { inlineData: { data: string; mimeType: string } }>> {
  const parts: Array<{ text: string } | { inlineData: { data: string; mimeType: string } }> = [];
  let hasAnyImage = false;

  if (payload.problemUploadUrl && payload.problemUploadUrl.trim() !== '') {
    const problemPart = await urlToInlineDataPart(payload.problemUploadUrl, 'Problem Matrix');
    if (problemPart) {
      parts.push({ text: '=== PROBLEM MATRIX VISUAL CONTEXT ===' });
      parts.push(problemPart);
      hasAnyImage = true;
    }
  }

  const cleanInspirationUrls = (payload.inspirationUrls ?? []).filter(u => u && u.trim() !== '').slice(0, 4);
  if (cleanInspirationUrls.length > 0) {
    parts.push({ text: `=== INSPIRATION MATRIX REFERENCE VISUALS (${cleanInspirationUrls.length} provided) ===` });
    for (let i = 0; i < cleanInspirationUrls.length; i++) {
      const inspirationPart = await urlToInlineDataPart(cleanInspirationUrls[i], `Inspiration Matrix ${i + 1}`);
      if (inspirationPart) {
        parts.push({ text: `[Inspiration Reference Asset #${i + 1}]` });
        parts.push(inspirationPart);
        hasAnyImage = true;
      }
    }
  }

  if (hasAnyImage) {
    parts.push({
      text: `Based on the contextual visuals provided above, perform a deep architectural analysis. 
Analyze structural patterns, visual layouts, and cross-reference the Problem Matrix with any Inspiration Matrix images. 
Extract design principles, color systems, spatial arrangements, and emergent concepts that can inform the concept garden below.

${textPrompt}`,
    });
  } else {
    parts.push({ text: textPrompt });
  }

  return parts;
}

Algorithmic State Tracking & Diversity Constraining: The engine injects explicit context-aware guardrails into the systemInstruction via formatPetalDiversityGuidance. By inspecting the current canvas state (existingFlowers), it dynamically computes an optimal distribution array for petal counts (1–8). It then dictates explicit behavioral instructions _(e.g., highly boosting underrepresented counts) _to force structural diversity in subsequent generations.

This process is split into two parts: computing the diversity weights based on the canvas state, and formatting those weights into explicit behavioral instructions for the system prompt.

(i) Computing the Diversity Weights
This function inspects the current canvas state (existingFlowers) and calculates inverse frequency weights to boost underrepresented petal counts:

// Compute petal count diversity weights ──
// Returns a weighted probability array for petal counts 1-8
// based on what's already been used: less-used counts get higher weight
function computePetalWeights(existingFlowers: Flower[]): number[] {
  const counts = new Array(9).fill(0); // index 0 unused, 1-8
  for (const f of existingFlowers) {
    const pc = Math.max(1, Math.min(8, f.petals.length));
    counts[pc]++;
  }
  const total = existingFlowers.length || 1;
  // Weight = inverse of relative frequency, boosted for counts not yet used
  const weights: number[] = new Array(9).fill(0);
  for (let i = 1; i <= 8; i++) {
    const freq = counts[i] / total;
    // Give unused counts weight 3.0, heavily used counts minimum 0.1
    weights[i] = Math.max(0.1, 3.0 - freq * 8);
  }
  return weights;
}

(ii) Formatting the System Prompt Guardrails
This function translates the computed distribution state into explicit, structured text instructions (PREFERRED, OK, and DISCOURAGEDcounts) that are ultimately injected into the systemInstruction:

// Format diversity guidance for the AI prompt
function formatPetalDiversityGuidance(existingFlowers: Flower[]): string {
  if (existingFlowers.length === 0) {
    return `PETAL DIVERSITY: This is the first generation. Distribute petal counts across the full 1-8 range. Example: some flowers with 1-2 petals (peripheral), some with 3-5 (mid), some with 6-8 (central/rich).`;
  }

  const counts = new Map<number, number>();
  for (const f of existingFlowers) {
    const pc = Math.max(1, Math.min(8, f.petals.length));
    counts.set(pc, (counts.get(pc) ?? 0) + 1);
  }

  const used = Array.from(counts.entries()).sort((a, b) => b[1] - a[1]);
  const unused = [1, 2, 3, 4, 5, 6, 7, 8].filter(n => !counts.has(n));
  const overused = used.filter(([, c]) => c >= 2).map(([n]) => n);
  const underused = used.filter(([, c]) => c === 1).map(([n]) => n);

  const lines: string[] = [
    `PETAL DIVERSITY (existing state):`,
    `  Current distribution: ${used.map(([n, c]) => `${n} petals ×${c}`).join(', ')}`,
  ];
  if (unused.length > 0) {
    lines.push(`  PREFERRED counts (not yet used): [${unused.join(', ')}] — strongly prefer these`);
  }
  if (underused.length > 0) {
    lines.push(`  OK counts (used once): [${underused.join(', ')}]`);
  }
  if (overused.length > 0) {
    lines.push(`  DISCOURAGED counts (used 2+ times): [${overused.join(', ')}] — avoid if possible, but may use if truly necessary`);
  }
  lines.push(`  Goal: maximize spread. If all 1-8 are used, repeat least-used counts only.`);
  return lines.join('\n');
}

Strict JSON Extraction Pipeline: The system utilizes a multi-tiered fallback parsing mechanism (extractJSON) to sanitize model outputs. It uses regex cleanups to guarantee that the structured tree output containing project_metadata, reasoning_stream, canvas_layout, and the harvest_panelcan be safely parsed even when under extreme temperature scaling.

function extractJSON(rawText: string): any {
  let cleaned = rawText.trim()
    .replace(/^```
{% endraw %}
(?:json)?\s*/i, '')
    .replace(/\s*
{% raw %}
```\s*$/i, '')
    .trim();

  const start = cleaned.indexOf('{');
  const end = cleaned.lastIndexOf('}');
  if (start === -1 || end === -1 || end <= start)
    throw new ParseError('No valid JSON object found in model response.');

  const jsonStr = cleaned.slice(start, end + 1);
  try { return JSON.parse(jsonStr); } catch (_) {}

  try {
    const repaired = jsonStr
      .replace(/,\s*([}\]])/g, '$1')
      .replace(/([{,]\s*)(\w+)\s*:/g, '$1"$2":');
    return JSON.parse(repaired);
  } catch (e) {
    throw new ParseError(`Could not parse model response as JSON: ${(e as Error).message}`);
  }
}

🔥 Why It Was the Only Best Choice

Why Gemma 4 MoE Rules: Standard models blend ideas like a blender, leaving you with a gray, uninspired mush when you try to mix two different topics. Gemma 4 MoE does not blend; it grafts. Because of its specialized gating network, it allows a biological expert layer and a software architecture layer to argue and align token by token.
Zero Semantic Dilution via Active Routing: When standard models attempt to combine text and images, they suffer from semantic drift, watering down the unique properties of your inputs. Gemma 4’s routing network isolates your structural data, meaning a microscopic cell pattern and an engineering bottleneck remain completely pure until the exact millisecond they collide to sprout a mutant idea.
Surgical Pruning Without Model Collapse: Standard architectures break down if you try to manually alter their data parameters mid-session. Because BLOOM maps data nodes directly to Gemma 4’s routing layers, deleting a specific petal on your screen instantly forces the model to dynamically reroute its logic paths, pruning away unwanted sub-entities in real time without causing creative collapse.
Cultivating Unbounded Imagination: Traditional lightweight dense models run out of cognitive steam when dealing with multi-modal inputs, forcing you to compromise on creative depth. By deploying the massive 26B Mixture-of-Experts architecture, BLOOM gives individual creators the staggering intellectual depth of an enterprise-grade engine while maintaining a highly optimized, lightning-fast local canvas footprint.
Creative Independence for Solo Builders: Rather than relying on rigid, heavily censored corporate platform guardrails that filter out fringe ideas, the open weights of Gemma 4 running through Google AI Studio give you absolute creative freedom. It acts as an unbiased, hyper-flexible thought accelerator tailored specifically for individual creators to engineer solutions that go completely against standard conventions.

🌐 Join the Movement & Cultivate the Future

The entire ecosystem is fully built, hyper-optimized, and ready for you to explore right now. Dive into the code, check out the live performance, or watch the engine in action through the official links below.

🌸 Launch the Lab: https://trybloomlabs.vercel.app/

NOTE:

Please allow 1 to 3 minutes for the engine to analyze your problem matrices, sprout its reasoning and cultivate your breakthrough. Hang tight to see the magic bloom!
Thank you for your patience!

🌸 Explore the Codebase: https://github.com/pmrinal2005/BLOOM.git

🌸 Watch the Demo: https://youtu.be/2nzXjrcIF18?si=PWce5YJMGGDX_dct