DEV Community: sanjay poudel

Pacer - The Voice-Guided Offline Run Coach

sanjay poudel — Mon, 12 Oct 2026 06:32:56 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

I built Pacer, a voice-guided, AI-powered running coach that lives in your pocket and forces you to look at the real world.

You put your headphones on, start the app, and put your phone away. From there, Pacer acts as your companion on the trail. It gives you pacing advice, encouragement, and—most importantly—periodically prompts you to look up from your screen and notice your surroundings (the wind, the trees, the clouds).

It is built for runners, hikers, and walkers who want the guidance of a coach without ever having to look at a screen. With Pacer, the screen time is literally zero. The AI is just the prep step and the background companion; the real experience is the run.

Code

github link : https://github.com/sanjaynep/ollama-practice
code snippet:

import whisper
import ollama
from elevenlabs import generate, play, set_api_key, VoiceSettings

# 1. THE EARS: Local Open-Source Whisper (Transcription)
def record_and_transcribe(duration=5):
    audio_data = sd.rec(int(duration * SAMPLE_RATE), samplerate=SAMPLE_RATE, channels=1, dtype='float32')
    sd.wait()
    result = whisper_model.transcribe(audio_data.flatten(), fp16=False)
    return result["text"].strip()

# 2. THE BRAIN: Local Open-Source Llama 3 (Reasoning)
def get_ai_response(user_input):
    chat_history.append({"role": "user", "content": user_input})
    response = ollama.chat(model='llama3', messages=chat_history)
    ai_message = response['message']['content']
    chat_history.append({"role": "assistant", "content": ai_message})
    return ai_message

# 3. THE MOUTH: Cloud ElevenLabs (Expressive Voice)
def speak(text):
    audio = generate(
        text=text,
        voice="Rachel",
        model="eleven_multilingual_v2",
        voice_settings=VoiceSettings(stability=0.6, similarity_boost=0.75, style=0.3)
    )
    play(audio)

How I Built It

Pacer is built on a hybrid architecture that leverages open-weight models for the core processing, and a cloud API only for the final output polish.

The Brain (Open-Weight / Local): I use Llama 3 (8B) via Ollama for the AI reasoning. It runs 100% locally on the machine. I gave it a strict system prompt to keep responses to 1-2 sentences and to actively remind the runner to observe nature.
The Ears (Open-Source / Local): I use OpenAI's Whisper (Base) model running locally via the whisper Python library to transcribe the runner's voice in real-time.
The Mouth (Cloud API): I use the ElevenLabs API for Text-to-Speech. I initially tried offline TTS (pyttsx3), but the robotic voice broke the immersion of a human coach.
The Loop: The app runs a background thread that triggers the LLM every 90 seconds to proactively check in with the runner. If the runner presses the spacebar (mapped to a bluetooth headphone button), it records 5 seconds of audio, transcribes locally, thinks locally, and speaks via the cloud.

Why Does Open Innovation Matter?

Open innovation is the only reason this app functions in the real world.

Running happens outside—often in canyons, forests, or trail systems with zero cell service. If I relied on a closed API (like OpenAI or Anthropic) for the LLM and Whisper, the app would literally crash the moment the runner loses a data signal. Because Llama 3 and Whisper run locally, the core reasoning and listening capabilities of the coach are guaranteed to work offline.

Furthermore, closed APIs cost money per token. A 45-minute run with continuous back-and-forth chatting would cost a few dollars via a cloud provider. Running Llama 3 locally costs exactly $0, meaning the runner can talk to their coach for hours for free.

Finally, a running app is highly personal. By keeping the STT and LLM local, the runner's voice data and conversational context never leave their device.

The only non-open piece is ElevenLabs, which I used for the expressive voice. A robotic voice makes for a terrible running coach. However, because the LLM and STT are offline, the app only pings the server for a few seconds to generate short audio clips, which works even on spotty 3G data, while the heavy lifting stays local and private.

Prize Categories

Best Use of ElevenLabs (Giving an open-source Llama 3 agent a highly expressive, human-like voice to make the running coach immersive)
Touch Grass Main Track (Zero screen time, actively prompts the user to look at their physical surroundings while running outside)

Buddy Base:Built an LLM Powered Group Chat for My Friends to Make Plans This Weekend

sanjay poudel — Mon, 05 Oct 2026 12:10:28 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

BuddyBase — a private, offline web application that gives your friend group a shared AI assistant. It runs entirely on your laptop. Friends connect through your local network (WiFi, Bluetooth tethering, or mobile hotspot). No data ever leaves your machine.
Four Features, All AI-Powered

Group Chat with AIA real-time chatroom where anyone can summon the AI by typing @buddy. It knows your group name, all members, and the last 20 messages for context. It responds like a friend who's always around — casual, funny, and actually helpful.
Decision MakerCreate a question with options. AI immediately gives a recommendation with reasoning. Everyone votes. After each vote, AI updates its recommendation considering the majority. No more 40-minute indecision loops.
Smart Shared ListsCollaborative lists where anyone can add items. Ask the AI to "suggest 5 more movies like these" or "what are we forgetting for the road trip?" It reads the list and gives real suggestions.
Personal BuddyEach friend gets a private AI assistant that learns their preferences. Tell it "I love spicy food" and next time someone asks about dinner, your buddy already knows. Memories persist in the database forever.

Demo

cannot make it in production but will be surely enhanced it and make it to production

Code

github link : https://github.com/sanjaynep/django-websocket

Key Code: AI Engine

This is the core — loads Qwen once using lru_cache, generates responses using the same apply_chat_template pattern from HuggingFace, with timeout handling via ThreadPoolExecutor:

@lru_cache(maxsize=1)
def _load_llm():
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
    model = AutoModelForCausalLM.from_pretrained(
        MODEL_NAME,
        torch_dtype=torch.float32,
        device_map={"": "cpu"},
    )
    model.eval()
    return tokenizer, model

def _generate(messages):
    tokenizer, model = _load_llm()
    text = tokenizer.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=True
    )
    model_inputs = tokenizer([text], return_tensors="pt").to("cpu")
    generated_ids = model.generate(**model_inputs, max_new_tokens=256, do_sample=True)
    output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()
    return tokenizer.decode(output_ids, skip_special_tokens=True).strip()

def chat(messages):
    with ThreadPoolExecutor(max_workers=1) as executor:
        future = executor.submit(_generate, messages)
        return future.result(timeout=60)

Key Code: WebSocket Consumer

class GroupChatConsumer(AsyncWebsocketConsumer):
    async def receive(self, text_data):
        message = json.loads(text_data).get('message', '').strip()
        user = self.scope['user']

        chat_msg = await self._save_message(user, message, is_ai=False)
        await self.channel_layer.group_send(self.room_group_name, {
            'type': 'chat_message',
            'message': message,
            'username': user.username,
            'is_ai': False,
            'time': chat_msg.created_at.strftime('%H:%M'),
        })

        if '@buddy' in message.lower():
            await self.channel_layer.group_send(self.room_group_name, {
                'type': 'typing_indicator',
            })
            ai_response = await self._get_ai_response()
            ai_msg = await self._save_message(None, ai_response, is_ai=True)
            await self.channel_layer.group_send(self.room_group_name, {
                'type': 'chat_message',
                'message': ai_response,
                'username': 'Buddy',
                'is_ai': True,
                'time': ai_msg.created_at.strftime('%H:%M'),
            })

Key Code: Preference Memory

def _try_save_memory(user, message):
    prefixes = {
        'i love': 'loves', 'i hate': 'hates', 'i like': 'likes',
        "i don't like": 'dislikes', 'my favorite': 'favorite',
    }
    for prefix, key_prefix in prefixes.items():
        if prefix in message.lower():
            value = message[message.lower().index(prefix) + len(prefix):].strip()
            BuddyMemory.objects.update_or_create(
                user=user, key=f"{key_prefix}_{value[:20]}",
                defaults={'value': value}
            )

How I Built It

Tech Stack
Layer Technology Why
Backend Django 4.2 Clean MVC, auth, ORM, admin panel out of the box
Real-Time Django Channels + WebSocket Messages appear instantly, no page reload
AI Model Qwen2.5-1.5B-Instruct via HuggingFace Transformers Runs locally on CPU, 3GB RAM, good chat quality
Frontend Vanilla JS + CSS Zero dependencies, works offline, no CDN needed
Database SQLite Local file, zero setup, perfect for small group
Server Daphne (ASGI) Supports both HTTP and WebSocket

Open-Source AI I Used
Component What
LLM Qwen2.5-1.5B-Instruct by Alibaba
Inference HuggingFace Transformers

PyTorch PyTorch (CPU build)
Framework Django

WebSocket Django Channels

Why Does Open Innovation Matter?

Privacy is not a feature, it's a fundamental right.
If I used OpenAI's API or Google's Gemini API for this project, every message my friends send — their food preferences, their votes, their inside jokes, their travel plans — would be sent to a third-party server. That data would be logged, possibly used for training, and stored in someone else's database forever.

With open-weight models like Qwen, that doesn't happen.

My friends' data stays on my laptop. In a SQLite file that I control. I can delete it, back it up, or move it. Nobody else has access.
No API keys to leak. There are no API keys in the code. No .env file with secrets. No billing account to worry about.
No internet dependency. We used this at a cabin with no WiFi. I turned on mobile hotspot, everyone connected, and the AI still worked because Qwen runs locally.
No usage limits. No "you've exceeded your quota" errors at 3 AM when we're still planning. The model runs as long as my laptop is on.
Full customization. I can change the AI's personality, what it remembers, how it makes decisions. Try getting ChatGPT to always pick a restaurant based on your group's dietary restrictions. With open models, I just edit the system prompt.
Zero cost. Running Qwen2.5-1.5B on my laptop costs exactly $0. Forever. For unlimited messages, unlimited friends, unlimited decisions.
Open innovation made this possible because:

Qwen's Apache 2.0 license lets me use it commercially or personally without restrictions
HuggingFace Transformers provides the inference engine for free
Django's BSD license gives me a production-grade web framework for free
Django Channels adds real-time capabilities for free
A closed API would make this project either impossible (no offline mode), expensive (paying per message for 5 friends chatting all weekend), or privacy-violating (sending personal preferences to the cloud). Open models make it free, private, and offline.

WHERE is ELON MUSK

sanjay poudel — Sun, 05 Jul 2026 14:27:25 +0000

The tilt and turn

sanjay poudel — Sun, 21 Jun 2026 16:56:00 +0000

This is a submission for the June Solstice Game Jam

What I Built

The tilt and Turn game
The objective of The Tilt and The Turn is to guide your character (the bright white silhouette) from the bottom of the world to the Turning Point Shrine at the very top of the level.
Along the way, you must
1.Manage the angle of the world using keyboard tilt controls to manipulate gravity and shadows.
2.Manage your vitality (avoiding active hazards) and the ticking solar clock to achieve one of three distinct narrative endings (Dawn, Noon, or Dusk) depending on the time of day you reach the finish
The game firstly will feel tricky but continue to reach that goal

How it related to june solstice game

The game consists of two dots red and blue:
Red dots: Touching it opens a reflection on June 19, 1865 (Juneteenth). It describes how the news of freedom arrived two and a half years late to enslaved people in Texas, casting "long shadows" of a delayed truth. It represents the idea that freedom is a slow, steady turning of the entire world.

Blue dots:Touching it opens a reflection on June 28, 1969 (The Stonewall Riots / Pride). It describes how those living in the shadows stood up into the light in Greenwich Village to fight for visibility, reminding us that being seen requires courage.

Purple dot: Touching it reveals a reflection on June 21st (The Summer Solstice), the longest day of the year, symbolizing how we stand on the shoulders of those who came before us to tilt the axis of progress.

Most interestingly when the clock time reach to 12:00 that is noon then the world suddenly tilt opposite showing the time changes from the long period to short period from that time that is after june 21

What we should consider while playing it

We should consider the game to reach the goal in every way where there will be obstacles like blue boxes and where gravity also plays role to loose us but we should continue to reach our goal each time and will end on these conditions(early before 11:30 or between 11:30 AM and 1:30 PM or after 1:30 PM) with different messages will shown each time when we reach goal.

Once you read your ending, you can click "Re-Align the Axis" to restart and try to reach the goal at a different time of day to experience the other stories.

Video Demo

Game link:demo
TO play it there is proper commands that is given in starting of game and we simply need to reach goal which is blowing candle passing all obstacles.
keep in mind sometime doing nothing can also fixes everything as Time will heal everything and make our life adjustable to these things. Simply dosn't loose hope

Code

Github link:github

How I Built It

I made it through Html,css and javascript as it fully contain staticfiles. so its web game which can play it in any browser. Click link and play it simple as it is

Prize Category

Best Google AI Usage: Created with google AI studio where it helped me a lot with physics values and Dynamic UIs. The environment work perfectly for me to code ,to debug and to execute it which help me a lot.

Any python developer here?

sanjay poudel — Tue, 09 Jun 2026 16:37:46 +0000

who want to be instructor in my ml journey?

Hospital management System :Based on symptoms prediction disease and doctor suggestion

sanjay poudel — Wed, 03 Jun 2026 17:50:55 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

In real-world scenarios, people are often unsure which doctor to consult for specific symptoms. To address this, I developed a Hospital Management System where users can book appointments based on predicted diseases. The system uses a Random Forest Classifier model, achieving 95% accuracy in predicting diseases from symptoms. Once a disease is predicted, the system automatically suggests the appropriate specialist. For example, if heart disease is detected, it recommends consulting a cardiologist.

Demo

You can easily find my project on GitHub at: https://github.com/sanjaynep/Hospital-management-system
Go and check it out, and also provide me with suggestions for future enhancements. I have mentioned how to get started in the README.

The Comeback Story

At first, I worked on the idea with only a JWT authentication system. Later, I decided to expand it into a Hospital Management System with simple registration, login, logout, authentication, authorization, and a hospital management dashboard. After learning about this challenge, I integrated an ML model to help predict diseases. I also containerized the application and implemented an async task that automatically cancels appointments after 24 hours if no response comes from the doctor, allowing users to book another appointment. In addition, I added 18 unit tests, all of which passed, ensuring the project follows the waterfall model of software development lifecycle.

My Experience with GitHub Copilot

GitHub Copilot helped me a lot in this project. It provided workflow designs and supported me with frontend development, as I mostly work as a backend engineer. Copilot assisted in testing, writing blocks of code, and evaluating models to choose the most suitable one. It also helped me with debugging errors, optimizing functions, and suggesting clean coding practices. In addition, Copilot guided me in structuring APIs, designing the dashboard layout which made the overall development process faster and more efficient.
here are my some images about my project

This overall project has helped me gain valuable experience in full‑stack development, machine learning, and DevOps. GitHub Copilot worked like a friend throughout the process, supporting me in designing workflows, writing code, testing, and refining the project to give it a polished and professional touch