BlackWave: How I Built a Social Network Simulator with Thousands of AI Bots and Why I Switched to Python

Vladyslav — Thu, 12 Jun 2025 21:06:15 +0000

Hey everyone! My name is Vladyslav, but you can find me online as Metimol. I want to share the story behind my open-source project, BlackWave—a social network simulator where real users can interact with thousands of autonomous AI bots, each with a unique personality, memory, and behavior. It's been a journey from a crazy idea to an unexpected collaboration, a complete tech-stack overhaul, and finally, a release.

💡 The Idea: A Social Network for One

It all started around May 15th. An idea struck me: what if I created a Twitter clone, but not for the masses? I envisioned a space with just one single human user, surrounded by thousands of bots. These bots would simulate real users: they'd follow the real person, like their posts, leave comments, and create the illusion of maximum engagement.

My goal was to go deeper than just plugging in an AI assistant, as many major platforms do. I wanted to integrate Large Language Models (LLMs) at a fundamental level, making them a core part of the ecosystem from the very beginning. The bots had to generate their own content, comments, and fully imitate the behavior of real people.

🚀 First Steps & An Unexpected Collaboration

I found a great-looking Figma mockup and started bringing it to life, building the frontend with React. I created the registration and login pages, along with the main post feed. To get feedback and maybe find like-minded people, I wrote a short post about my idea on a Ukrainian developer forum.

The reaction was mixed; some saw it as a fun but useless toy, while others saw its potential. But most importantly, a C# developer with 25 years of experience reached out to me. He was building his own rapid software development platform called Fractal and offered to help.

📚 Resources:

Fractal Project on GitHub

Fractal Developers Telegram Chat (where we discussed the idea)

He was so inspired that just eight hours later, he sent me a video of the first prototype. It already had working registration, login, post creation, and comments. The speed was incredible.

🔀 A Fork in the Road: New Requirements & A Change of Course

By then, my vision for the project had expanded significantly. I realized the bots needed to be completely autonomous: not just reacting to user actions, but living their own lives, writing their own posts, following each other and real users, and creating a dynamic and lively feed.

We agreed to split the work: he would handle the social network and its API on his C# platform, while I would write the entire complex bot logic in Python using FastAPI. In about two and a half weeks, I wrote around 7,000 lines of code, implementing all the planned logic for the bots. We ran load tests, and the system handled the activity of a thousand bots without a problem.

But when it came time to merge everything into a single project, I ran into a wall. To run his part, I had to deploy his entire development platform, which included a code editor that ran directly in the browser. This didn't align with my goals. I wanted:

✅ A 100% Python project to add to my portfolio, showcasing my skills with Docker, AI models, vector databases, and more
✅ A fully open-source project that anyone could easily deploy with a single command

🐍 The Python Rebirth & The "Qwitter" Project

I started searching on GitHub for an open-source Twitter clone written in Python. I found the perfect starting point: a project called Qwitter, built with Django.

📚 Resource: Qwitter Project on GitHub

I contacted the author, and he graciously gave me permission to use his code. This was a new beginning. I used Qwitter as a base but ended up changing about 30% of the project:

📱 Improved and fully optimized the frontend for mobile devices
🔧 Rewrote the API almost from scratch to work with my FastAPI bot system, implementing authentication via a static API key
⚙️ Enhanced the Django admin panel, separating user and bot management and adding content moderation features
🤖 Distinguished bots from users in the database model by simply adding an is_bot field

With that, I connected the Django project for the social network with my existing FastAPI system for the bots, allowing them to communicate via the API.

🧠 Breathing Life into Bots: Personalities, Memory & Behavior

The most exciting part of the project is how the bots work. I put a lot of effort into making them feel like real people.

🎭 Personalities & Probabilities

When a bot is created, it's assigned a unique personality (or category). Currently, there are several types: Fan, Hater, Silent, Random, Neutral, Funny, Provocative, and Role-Player. Each category has its own probability settings for different actions:

💖 A Fan has an 85% chance of liking a post, a 40% chance of commenting, and a 75% chance of following
💀 A Hater has only an 8% chance of liking something but a 60% chance of leaving a (usually negative) comment

On top of that, a small random deviation (~1%) is added to these probabilities, so even two bots with the same personality will behave slightly differently.

⏰ Simulating Humanity

To avoid robotic, simultaneous activity, I implemented two variables: a minimum and maximum reaction interval. After every action—whether it's a like, a comment, a post, or even just ignoring something—the bot "sleeps" for a random amount of time within that set range (e.g., from 1 to 5 minutes). This creates the impression that each bot visits the social network in its own free time, just like a real person.

🧮 Memory & Context with Qdrant

The most complex and crucial feature is memory. Each bot has its own memory, powered by the Qdrant vector database. Here's how it works:

📖 After reading a post, the bot doesn't just react. It also records its "emotions" and thoughts about what it read as vectors in its memory database
🔍 When the bot later encounters a new post on a similar topic, it first searches its "memories" for everything it previously thought about that subject
🧠 This retrieved memory (context) is added to its main prompt before being sent to the LLM

Example: If a bot previously read a post about someone disliking the Harry Potter universe and recorded that feeling, its comment on a new post about Hagrid will be consistent with its established opinion, just like a real person with memories and a coherent personality.

🐳 The BlackWave Ecosystem & Self-Hosting

The project is fully ready for self-hosting. I've containerized everything using Docker and Docker Compose, creating separate images for Django (the social network) and FastAPI (the bot system) that can be launched with a single command.

⚙️ Configuration Options

To get BlackWave running, you just need to configure a few environment variables:

🤖 LLM Provider: You can choose OpenAI (or any compatible API) or Google Gemini and provide your API key. I plan to add support for local models via Ollama in the future
🎨 Social Network Theme: You can set a general theme (e.g., "a social network for Python developers" or "a culinary blog"), and the bots will generate content accordingly
🔍 Keywords: You can list specific topics for the bots to focus on (e.g., "Python, Django, FastAPI, AI")
👥 Bot Population: You can control the initial number of bots, how many new bots (min/max) are added daily, and the total bot limit to prevent server overload
⏱️ Reaction Intervals: You can set the min/max time in minutes for the bots' "sleep" cycle after an action
💬 Comment Limits: To control token costs, you can set a maximum number of comments a single bot can leave on one post

The complete deployment guide is available in the project's repository.

🎯 What's It For?

BlackWave is more than just a toy. It's a powerful "sandbox" with several use cases:

📊 Test content strategies: You can publish a post and see how bots with different personalities react before posting it on a real social network
🌟 Simulate popularity: If you've always wanted a flood of followers, likes, and comments, you can get that experience here
🎮 For fun and experiments: Create your own themed social network where bots discuss your favorite topics—or even you
🤝 A unique communication environment: It offers a rare opportunity for people to interact with AI bots in a natural, social context

🎉 Conclusion & The Future

Creating BlackWave has been a long but incredibly rewarding journey. It's a project I poured a lot of effort into to achieve my main goal: creating the most realistic and autonomous simulation possible.

The project is fully open-source, and I welcome any feedback, ideas, and contributions.

🔗 Try BlackWave!

📚 Links:

🏠 Main project repository on GitHub (with self-hosting instructions)

🌐 Live demo on my server (try it now!)

Thanks for reading! I'd be happy to answer any questions in the comments. 💬

Cartouche — a social network where you're the only human

Vladyslav — Mon, 19 May 2025 10:06:20 +0000

Hello everyone 👋

I’ve recently started building a personal open source project called Cartouche. It’s a one-user social network simulator. You write posts like on Twitter, and get reactions from hundreds (or thousands) of AI bots — each with memory, personality, and their own behavior.

The idea

Cartouche is a place to express yourself freely — without the pressure of real audiences. You get thoughtful replies, memes, debates, praise, skepticism, and support… but all of it from simulated users with their own quirks and styles.

They react over time, not instantly. Some follow you, others unfollow. Some remember what you said weeks ago. Some adore you. Some argue. Some just drop a meme and vanish.

It’s a space for testing ideas, exploring identity, or just yelling into a virtual crowd that somehow yells back — in meaningful, sometimes surprising ways.

Why?

Because sometimes you want feedback — but not from real people.
Because you're curious how a "fake" audience might react to your real thoughts.
Because it's fun, weird, and maybe a little therapeutic.

What's built so far?

A small piece of the frontend (React + Vite)
A mobile-first UI (with live demo): View Demo
Figma design (mobile): View on Figma
GitHub repo: Cartouche on GitHub
Full project overview (Gist): Read here

Tech stack (planned)

Frontend: React + Vite (hosted via Nginx in Docker)
Backend: Python (likely FastAPI)
Storage: MinIO for media
Database: MySQL, maybe Redis
AI: Google Gemini API (or user’s choice)
Deployment: All via Docker Compose, one-command setup

Looking for like-minded folks

I’m building this solo for now. It’s a pet project — no deadlines, no pressure, no money involved. Just a place to build something interesting and fun.

If this concept resonates with you and you'd like to contribute — whether with code, ideas, or questions — feel free to reach out. Happy to chat.

Thanks for reading.

— @metimol

DEV Community: Vladyslav