🦋 I Built a Living Terminal Animation with Hermes Agent — Here's How It Went.

Aditya Madhok — Tue, 26 May 2026 17:54:48 +0000

Hey DEV community! I'm Aditya Madhok, and this is my submission for the Hermes Agent Challenge — a $1,000 prize pool challenge to build something cool using the open-source Hermes Agent. I ended up building something I genuinely didn't expect to pull off: a fully animated, living Butterfly Garden that runs right inside your terminal.

No GUI. No browser. Just pure Python + ANSI escape codes + a surprisingly capable AI agent.

🌸 What Is Butterfly Garden?

It's a terminal animation — a little scene that plays out in your 80x24 character grid. Here's what's happening on screen at any given moment:

🦋 A butterfly with a full state machine (Seeking → Landing → Sipping Nectar → Taking Off), flapping its wings in animated sprite cycles
🌺 Three flowers (a tulip, a daisy, and a rosebud) that sway gently with a sine-wave wind effect
✨ Floating pollen/sparkle particles drifting across the scene
🌿 Two layers of animated grass at the bottom, tilting left and right with the breeze
📜 A live narrative caption that changes based on what the butterfly is doing

The whole thing runs at ~12fps using a double-buffered render loop — meaning every frame, a fresh character and color buffer is computed, then flushed to the terminal in one write. No flicker. No tearing.

python butterfly_garden.py

That's all it takes. Press Ctrl+C to exit gracefully (cursor is restored, colors reset).

🤖 Where Does Hermes Agent Come In?

Here's the honest truth about how this got built.

I had the idea — a terminal animation with a butterfly visiting flowers. I knew the broad shape of it. What I didn't have was hours to manually tune physics, sprite timing, state machine transitions, and sine-wave grass. That's where Hermes Agent came in.

Hermes Agent is an open-source agentic system built for planning, tool use, and multi-step reasoning. It runs on your own infrastructure. I described what I wanted and let it help me reason through the architecture piece by piece:

Me: "I want a butterfly that realistically seeks out flowers, lands on them, sips nectar, then flies to the next one."

Hermes: Suggested a 4-state machine — SEEKING, LANDING, RESTING, TAKEOFF — with spring-based physics for smooth movement and a flutter noise layer for organic-looking flight.

That's the kind of architectural help that turns a vague idea into structured code fast. Hermes wasn't just autocompleting lines — it was helping me think about the problem.

🧠 The Interesting Technical Bits

Double-Buffered Terminal Rendering

def create_double_buffer():
    char_buf = [[" " for _ in range(WIDTH)] for _ in range(HEIGHT)]
    color_buf = [[RESET_COLOR for _ in range(WIDTH)] for _ in range(HEIGHT)]
    return char_buf, color_buf

Every frame builds two full 80×24 grids — one for characters, one for ANSI color codes. This gets flushed in a single sys.stdout.write() call, which prevents the partial-frame flickering you'd get from printing line by line.

Spring Physics + Flutter Noise

The butterfly doesn't just teleport to targets. It uses velocity + spring acceleration:

ax = (target_x - bx) * 0.06
ay = (target_y - by) * 0.06

flutter_x = math.sin(frame * 0.8) * 0.6
flutter_y = math.cos(frame * 1.1) * 0.4

vx = vx * 0.8 + ax + flutter_x * 0.1
vy = vy * 0.8 + ay + flutter_y * 0.1

The damping (* 0.8) prevents oscillation. The flutter noise (different frequencies on X and Y) creates that natural drifting quality real butterflies have.

Swaying Flowers via Sine Waves

def update(self, frame):
    self.sway_x = math.sin(frame * 0.04 + self.base_x) * 2.5

Each flower has a phase offset (+ self.base_x) so they don't all sway in sync — that one line makes the scene feel alive instead of mechanical.

The Butterfly Locks to the Flower While Sipping

When the butterfly is in RESTING state, it doesn't use physics at all:

elif b_state == 2:
    bx = flower_top_x  # flower_top_x updates every frame as flower sways
    by = flower_top_y

This means the butterfly visually rides the swaying flower — a tiny detail that sells the whole illusion.

🎨 What It Looks Like

────────────────────────────────────────────────────────────────────────────────
         BUTTERFLY GARDEN

     ✧  ·  ✧       o   o          ✧
                  / \_/ \
           \_/  (_ _O_)   (@)
            v   \_/ \_/   \|/
        |        |  |      |
      y |      y |  | p    | p
        |        |  |      |
 \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
         Sipping sweet nectar from a swaying blossom...
wvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwv

(ANSI colors render in the terminal — the butterfly shifts between orange and magenta, flowers bloom in cyan, red, and purple, grass glows green)

💡 What I Learned from Using Hermes Agent

It's excellent for architecture decisions. Asking "how should I structure the state machine?" got me a clean answer with tradeoffs explained. That's different from autocomplete.
It accelerates the boring math parts. Sine wave phase offsets, spring damping coefficients, sprite index oscillation from sin() — Hermes helped me get these right without trial-and-error guessing.
You still write the code. Hermes is an agent, not a vending machine. The final implementation is mine — but it's shaped by reasoning I did with it, not alone.
Running on your own infra matters. For a creative/personal project like this, I didn't want my prompts going anywhere proprietary. Hermes running locally gave me that freedom.

🚀 Try It Yourself

The script is self-contained — no dependencies beyond Python 3 and a terminal that supports ANSI codes (Linux/macOS out of the box, Windows Terminal works too).

# Clone or download butterfly_garden.py, then:
python butterfly_garden.py

# Exit with Ctrl+C — the terminal resets cleanly

The code is around 300 lines and heavily commented. If you want to mod it:

Add more flowers by appending to the flowers list
Change WIDTH/HEIGHT to fit your terminal
Swap BUTTERFLY_SPRITES for your own ASCII art frames
Tune flap_speed per state for different animation feels

Final Thoughts

I didn't expect a terminal animation to be this satisfying to build. There's something meditative about characters, math, and color codes combining into something that feels alive. Hermes Agent made the architectural reasoning faster and more fun — it's a tool that respects your intelligence while expanding what you can accomplish alone.

If you have questions, want to share your own Hermes Agent builds, or just want to talk terminal art — drop a comment below. I read every one. 👇

Built for the DEV Hermes Agent Challenge · May 2026 · by Aditya Madhok

Astro Career Mapper

Aditya Madhok — Fri, 30 Jan 2026 17:22:22 +0000

Choosing the right career path can be one of the most impactful decisions of a person’s life — but it’s also one of the most challenging. That’s why I created Astro-Career-Mapping, a free and open-source tool designed to help people reflect on their professional potential through a unique combination of astrology and esoteric knowledge. Hosted on GitHub under the MIT License, this project is built with accessibility and personal growth in mind.

At its heart, Astro-Career-Mapping provides users with a way to explore career direction using astrological insights. Rather than relying solely on generic personality tests or standardized career quizzes, this tool contextualizes your professional strengths and tendencies against the backdrop of your birth chart — allowing a deeper conversation with your own potential. This kind of self-reflection can be especially valuable for students, job seekers, or anyone thinking about a career pivot.

One of the major strengths of this project is that it’s free software. Because it’s licensed under MIT, anyone can use, modify, or build upon it — whether you’re a hobbyist developer, an aspiring astrologer, or a data-driven career coach. You can explore the code directly on GitHub, and even preview the live interface hosted via GitHub Pages. This openness encourages collaboration and improvement from the community, making career mapping a participatory experience.

In a landscape where many career-guidance platforms charge for assessments or limit access to premium features, Astro-Career-Mapping stands out as a free and transparent alternative. By combining ancient wisdom with modern web technologies, the tool invites users to think beyond traditional career frameworks and consider how deeper personality patterns may inform their professional lives. This can complement other career planning resources, whether they use conventional aptitude tests, AI-based analysis, or questionnaires.

I built Astro-Career-Mapping not just as a software project, but as a resource that sparks curiosity and self-discovery. Whether you’re looking for inspiration, clarity, or a new way to reflect on your goals, this tool offers a gentle, exploratory approach to career planning — and best of all, it’s available to anyone with an internet connection. Head over to the project repository to try it out, contribute, or adapt it for your own needs!

Here is the Link for this Project.

DEV Community: Aditya Madhok