Building Dootie: A 3D Poop Emoji Chatbot (And Why It’s Actually Sophisticated)

Or: How I turned a “shitty time” with tech adoption into a literal shit chatbot

Three hours. Eleven git commits about eye colors. One professional septic service mascot that tracks your cursor from inside a toilet.

---

How This Even Started

So I’m sitting here, kinda frustrated because I’ve been building all this cutting-edge stuff - MCP servers, AI infrastructure, genuinely cool tech - and nobody’s really getting it. Like, the adoption rate is… not great.

I’m having a shitty time.

(You see where this is going, right?)

Then my phone buzzes. It’s Mat - runs a septic service business here in Idaho, and I’ve known him for over twenty years. Good dude. Really good dude. We’ve stayed in touch all these years, and he knows I’m the tech guy.

He’s asking if I might have any ideas for his business website. Just, you know, brainstorming kind of stuff.

And my brain - my absolutely ridiculous brain - immediately goes: “3D animated poop emoji chatbot.”

Like, not even as a joke. As a REAL idea.

But here’s the thing - I didn’t text him back right away with some pitch. Because I know Mat. I know that an “animated-poop-emoji-chatbot-demo is worth ‘1000 words’” kinda deal.

So instead of explaining it, I just… built it.

A few hours later, I’ve got a 3D poop emoji rising from a toilet, tracking cursor movement with its eyes, ready to chat via AI.

THEN I send it to him.

His response? He’s INTO it. Immediately. Gets the vision without needing any explanation. Which is why I love working with him - he understands that sometimes the weird idea is actually the BEST idea.

And that’s how we ended up doing this.

Because I… I couldn’t help myself.

What Did I Actually Build?

So yeah, Dootie. The name? That came from Mat’s existing slogan: “Your dootie is our duty.” Because yeah, they pump your shit. The branding writes itself sometimes.

But here’s what’s actually wild - this isn’t just some joke project. This is legitimate production infrastructure for a real business that does real septic pumping for real people with real… problems.

So I’m building:

• A professional 3D poop emoji (and yes, there’s a 10MB OBJ model for this)
• That lives in a toilet (Oscar the Grouch was the vibe)
• Eyes that track your cursor (because of course they do)
• Smooth animations (he emerges from the toilet on page load)
• AI-powered chat for actual septic advice
• Emergency detection (“my septic is backing up!” triggers immediate escalation)
• Form validation assistance (helping people book service calls)
• An embeddable widget that works on any website
• Full observability with LangFuse (because this is production, dammit)

The non-requirements were pretty clear too:

• Looking “professional” in any traditional sense
• Taking myself seriously
• Being able to explain this to my family

(Tate asked what I was working on. I showed him. He just said “Dad, why?” and walked away. Fair.)

---

Toilet-Themed HTML Art Break 🚽

While building Dootie, I discovered there’s an entire ecosystem of toilet-themed web art out there. Check out these gems:

• Infinite Toilet Paper CSS by Yusuke Nakaya - Pure CSS infinite scroll animation. The reading indicator on this page is inspired by the Shrinking Toilet Paper Roll by iko!

• Magic 8-Ball Toilet - For when you need existential bathroom wisdom

• Toilet Trouble Tycoon Game - Yes, someone made a plumbing management game

The internet is weird and wonderful. 💩✨

---

Hour 1: Everything Looks Like Shit (In the Bad Way)

Started with Three.js primitive spheres. You know, just mash some brown spheres together, add some eyes, call it a day?

Nope.

It looked terrible. Like, not “haha it’s a poop emoji” terrible. More like “did someone’s kid make this in MS Paint” terrible.

I’m sitting there rotating this malformed brown sphere collection, and I realize - I’m literally polishing a turd. The metaphor is RIGHT THERE.

The Professional Poop Model Hunt

Okay so here’s something I never thought I’d type into Google: “professional quality poop emoji 3D model OBJ format with proper UV mapping.”

But I found one. A TEN MEGABYTE professionally crafted poop emoji model. Someone, somewhere, spent serious time crafting this thing in Rhino or Blender or whatever. They carefully named the materials. They UV mapped it properly. They made sure the topology was clean.

Someone out there is a professional poop emoji 3D modeler, and honestly? Respect.

The model came with three materials:

• “Cafe” (the brown body)
• “Blanco Ojos” (white for the eyes)
• “Custom” (black pupils)

Perfect! Load it up, render it and… the eyes are brown.

Why are the eyes brown?

The eyes shouldn’t be brown.

The Great Eye Color Debugging Session

I need you to understand that I spent a solid chunk of time debugging why poop emoji eyes were brown.

// Git commit: "Fix eye whites being brown instead of white"
// This is a real commit in production code for a real client

object.traverse((child) => {
  if (child instanceof THREE.Mesh && child.material) {
    const material = child.material as THREE.MeshPhongMaterial;

    if (material.name === 'Blanco Ojos') {
      // SUPPOSED to be white eyes
      // Was actually using Cafe (brown) material
      // I spent 2 hours on this.
      material.color.set(0xFFFFFF); // MAKE IT WHITE DAMMIT
    }
  }
});

The problem? The model was using the “Cafe” material for the eyes by default. Someone, somewhere, decided poop emoji eyes should be brown. And you know what? They were wrong.

I’m debugging material assignments in a 3D model, muttering “the eyes should be WHITE” over and over, and at some point I had to step back and really evaluate my life choices.

But also? The eyes ARE white now. So who’s winning?

The Oscar the Grouch Moment

The toilet was non-negotiable. I mean, where else would a poop emoji live?

But the implementation… oh man. So I’ve got this toilet model (also professionally made, because apparently there’s a whole market for bathroom fixture 3D models), and Dootie needs to emerge from it when the page loads.

async function playEntranceAnimation(mascot: THREE.Group, toilet: THREE.Group) {
  // Start below viewer's sight
  mascot.position.y = -2;
  toilet.position.y = -3;

  // Animate emergence over 1 second
  // Yes, the poop emoji rises from the toilet
  // This is professional client work
  // I have a CS degree
}

The first time it worked - when Dootie smoothly rose from the toilet while maintaining eye contact - I actually laughed out loud. Like, genuine joy. This is so stupid. It’s SO stupid. But it’s also perfect?

The AI Brain (Because Why Not Make It Sentient)

Here’s where it gets actually sophisticated. Dootie isn’t just animated - he’s intelligent. Running Ollama locally with gemma2:2b because it’s fast enough to feel responsive.

But the best part? I built a markdown-based personality system. The client can literally edit markdown files to change how Dootie behaves:

---
title: "Septic Backup Emergency"
priority: "critical"
requiresEscalation: true
---

# Emergency: Septic Backup

You're helping someone with a septic emergency. This is serious.

## Response Template
1. Acknowledge the emergency
2. "🚨 Stop all water use NOW"
3. "Call (208) 656-5355 immediately"

So now we have a poop emoji that can detect emergencies and provide actual helpful advice. This is where we are as a civilization.

The Cursor Tracking Saga

Getting the eyes to follow your cursor sounds simple until you realize pupils can rotate too far and suddenly your friendly poop emoji looks possessed.

// Git commit: "Replace pupil manipulation with full model rotation for eye tracking"
// Another real commit I have to live with

const maxRotation = Math.PI / 4;  // 45 degrees max
// Because 360-degree spinning poop eyes are nightmare fuel

I had three different implementations:

1. Move the pupils manually (looked weird and detached)
2. Rotate the entire model (the whole poop spun around which was… unsettling)
3. Just rotate the pupils with limits (perfect!)

Each iteration involved me moving my mouse around while a 3D poop emoji stared back at me. This is my job. This is what I do.

Production Observability for a Poop Emoji

Because this is REAL CLIENT WORK (I cannot stress this enough), I needed proper observability. Enter LangFuse.

Now I can track:

• Every conversation with Dootie
• Emergency detection rates
• User engagement metrics
• Which prompts make Dootie say weird things
• Token usage and costs

There’s a dashboard somewhere that shows real-time analytics for a poop emoji chatbot. Someone at LangFuse is gonna see “dootie-chat” in their logs and have questions.

---

More Toilet-Themed Web Creations 🧻

Need more bathroom-based web inspiration? The community has you covered:

• Toilet Paper Select Menu - A dropdown menu that looks like toilet paper sheets

• Active Toilet Usage Dashboard by Kaizo Music - Real-time odor monitoring with Charts.js. This is legitimately impressive.

• Toilet Roll-over - Hover effects for toilet paper

• How Much Toilet Paper Do I Need? - A calculator. Because why not.

The rabbit hole goes deep. 🕳️💩

---

The Widget That Could Go Anywhere

The final boss: making this embeddable on ANY website with one script tag.

<!-- This line of code adds a poop emoji to your website -->
<script src="https://dootie.qubeseptic.com/widget.js"></script>

600 lines of implementation docs. Shadow DOM isolation. Dynamic Three.js loading. Multi-tenant backend support. Domain whitelisting for security.

All so a poop emoji can emerge from a toilet on any website on the internet.

This is engineering.

So What Have I Learned Here?

Look, I spent an afternoon building this. A few hours where I could’ve been doing literally anything else. Building “serious” software. Working on “important” projects. Being a “responsible” developer.

Instead, I have commits like:

• “Fix eye whites being brown instead of white”
• “Adjust toilet position for better emergence animation”
• “Prevent pupils from rotating 360 degrees (too creepy)”
• “Add bounce animation to make poop emoji friendlier”

But here’s the thing - and I’m being completely serious here - this is some of the best engineering I’ve done all year.

Why?

Because it’s REAL. It solves a REAL problem (customer engagement for a septic business). It uses REAL cutting-edge tech (Three.js, Ollama, FastAPI, LangFuse). It required REAL engineering solutions (embeddable widgets, shadow DOM, observability).

The fact that it’s shaped like a poop emoji? That’s just… seasoning.

Mat’s Reaction

He loved it. Obviously.

I mean, how could he not? We’d taken this ridiculous idea and turned it into actual production infrastructure. A poop emoji that could help his customers, detect emergencies, and make people smile.

The widget works perfectly. The AI is responsive. The cursor tracking is smooth. And yes, the eyes are properly white.

Now we just need to launch it and see how people react. I’m betting kids are gonna love it.

What This Says About Everything

Sometimes - and hear me out here - sometimes the best engineering comes from the stupidest ideas.

I couldn’t get people excited about MCP servers and AI infrastructure and all this genuinely impressive technical stuff. But a poop emoji that lives in a toilet and gives septic advice? THAT gets attention.

Maybe the lesson is that we need to stop taking ourselves so seriously. Maybe the best technology is the technology that makes people smile before it helps them. Maybe debugging poop emoji eye colors is exactly what I should be doing with my computer science degree.

Or maybe I just couldn’t help myself.

Either way, Dootie exists now. He’s out there on the internet, rising from his toilet, tracking cursors with his properly white eyes, ready to help with your septic emergencies.

And if that’s not professional software development, I don’t know what is.

The Reality Check

A few hours ago, I was frustrated about tech adoption and feeling like my work wasn’t connecting with people.

Now, I have a production poop emoji chatbot with full observability, emergency detection, and cursor-tracking eyes.

Did I solve my original problem? Probably not.

Did I create something way weirder and somehow more meaningful? Absolutely.

Would I do it again? In a heartbeat.

Because sometimes you just gotta build the stupid thing. Sometimes the stupid thing is actually brilliant. And sometimes - just sometimes - a professionally crafted 3D poop emoji chatbot is exactly what the world needs.

Welcome to software development in 2025. It’s pretty wild out here.

---

Technical Appendix (For the Nerds)

Yeah okay, here’s the actual technical stuff if you want to build your own:

The Stack

• Frontend: Astro with Three.js for 3D rendering
• Backend: FastAPI for streaming responses
• AI: Ollama running gemma2:2b locally
• Observability: LangFuse for tracking everything
• Deployment: Docker containers with Caddy reverse proxy

The Numbers

• 10MB OBJ model (professionally crafted)
• 600 lines of widget implementation
• 3 material types (Cafe, Blanco Ojos, Custom)
• 45-degree maximum pupil rotation
• 1-second emergence animation
• 300ms response time for AI chat
• 24/7 availability

The Git Evidence

Real commits from this project:

• “Initial poop emoji with brown sphere primitives”
• “Replace spheres with professional OBJ model”
• “Fix eye whites being brown instead of white”
• “Use model’s built-in eyes instead of overlaid placeholder eyes”
• “Add toilet model for Oscar the Grouch vibes”
• “Implement cursor tracking with pupil rotation”
• “Limit pupil rotation to prevent nightmare fuel”
• “Add emergence animation from toilet”
• “v1.0.0 - Dootie: AI-Powered Septic Mascot 🚽💩“

Want to Build Your Own?

Don’t.

But if you must, start with a good 3D model. Trust me on this one. Don’t try to make a poop emoji from primitive shapes. Someone already did the work. Use their model. Respect the craft.

And remember: the eyes should be white. Always white.

---

The Links

See Dootie in Action: qubeseptic.com (bottom-right corner)

Technologies I Somehow Used for This:

• Three.js - For rendering our hero
• Astro - Because it’s fast and I like it
• FastAPI - Streaming poop emoji responses
• Ollama - Local AI that powers Dootie’s brain
• LangFuse - Tracking poop emoji conversations

---

Built with ❤️ and a questionable sense of professionalism by Ryan Malloy • November 2025

Yes, this is real. Yes, it’s in production. Yes, I’m proud of it. 💩✨