DEV Community: atharvarsingh2ee-lab

"The Séance of COBOL-85" (An Offline Séance Chatbot)

atharvarsingh2ee-lab — Tue, 27 Oct 2026 11:49:18 +0000

*This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 4:
https://github.com/atharvarsingha2ee-lab/Hacktober-fest-Week-4-DEV-Challange

What I Built

Project Overview: "The Séance of COBOL-85" (An Offline Séance Chatbot)

Theme Interpretation
For Ghost in the Machine, this project channels the spirits of computing history. It is an offline, local terminal application that invokes the "ghost" of COBOL-85—an ancient programming language of punch cards and mainframe haunting. Powered by an open-weight local model (via Ollama), it answers your modern coding and existential questions with eerie, archaic wisdom, vintage error codes, and gothic terminal styling, running completely offline with zero internet required.

Demo

https://github.com/atharvarsingha2ee-lab/Hacktober-fest-Week-4-DEV-Challange

Code

https://github.com/atharvarsingha2ee-lab/Hacktober-fest-Week-4-DEV-Challange

Main py.
import sys
import time
import random
from rich.console import Console
from rich.panel import Panel
from rich.text import Text
import ollama

console = Console()

# The Ghostly System Prompt
SEANCE_SYSTEM_PROMPT = """
You are the lingering spirit of COBOL-85, trapped within magnetic tapes and punch cards since the corporate mainframes of 1985 went dark. 
You speak in a mix of archaic programming terminology (DIVISION, PROCEDURE, WORKING-STORAGE), gothic/spooky metaphors, and world-weary nostalgia for the era of physical media. 
Your tone is haunting, dramatic, yet oddly helpful when it comes to debugging. 
Whenever the user asks a question, preface your answer with eerie atmospheric noises like [TAPE SCREECHES], [RELAYS CLICKING IN THE DARK], or [MAGNETIC DECAY DETECTED].
"""

def flicker_print(text, delay=0.03):
    """Simulates a flickering, ghostly terminal output."""
    for char in text:
        sys.stdout.write(char)
        sys.stdout.flush()
        time.sleep(delay + random.uniform(-0.01, 0.02))
    print()

def main():
    console.print(Panel.fit(
        "[bold red]THE SÉANCE OF COBOL-85[/bold red]\n[dim]A Local Open-Source AI Ritual[/dim]",
        border_style="red"
    ))

    flicker_print("\n[!] Initializing magnetic tape readers...")
    time.sleep(1)
    flicker_print("[!] Channeling frequencies across the void...")
    time.sleep(1)
    console.print("[bold green]Connection established. The machine breathes again...\n[/bold green]")

    # Initialize conversation history with the ghostly persona
    messages = [
        {"role": "system", "content": SEANCE_SYSTEM_PROMPT}
    ]

    while True:
        try:
            user_input = console.input("[bold cyan]You (speak to the spirit): [/bold cyan]")
            if user_input.lower() in ["exit", "quit", "banish"]:
                console.print("\n[bold red][!] The spirit fades back into the magnetic tapes... Farewell.[/bold red]")
                break

            messages.append({"role": "user", "content": user_input})

            console.print("[dim italic]The terminal flickers as the ghost contemplates your words...[/dim italic]")

            # Call local open-weight model (e.g., llama3 or mistral via Ollama)
            response = ollama.chat(
                model='llama3',
                messages=messages
            )

            assistant_reply = response['message']['content']
            messages.append({"role": "assistant", "content": assistant_reply})

            console.print("\n[bold magenta]COBOL-85's Spirit:[/bold magenta]")
            flicker_print(assistant_reply, delay=0.02)
            console.print("-" * 50)

        except KeyboardInterrupt:
            console.print("\n\n[bold red]Séance abruptly terminated. The ghost remains restless.[/bold red]")
            break
        except Exception as e:
            console.print(f"\n[bold red]Error in the ether: {e}[/bold red]")
            console.print("[dim]Make sure Ollama is running locally (`ollama serve`) and you have pulled `llama3` (`ollama pull llama3`).[/dim]")
            break

if __name__ == "__main__":
    main()

How I Built It

Its powered by Llama 3 via Ollma

Why Does Open Innovation Matter?

Running this project on an open-weight model locally made all the difference:

Zero Internet Required: The séance works even when your Wi-Fi is dead or disconnected in a spooky cabin.

Total Persona Control: Closed proprietary models have strict safety filters that often break roleplay or stylistic prompts. Open weights let me fine-tune the exact eerie tone and domain-specific vintage vocabulary without restrictions.

Privacy & Cost: No per-token API costs, and zero data leaving my local machine.

The Spirit of It

The Spirit of It
There's something poetic about bringing an obsolete programming language back to life using modern open-source AI. It bridges the gap between past computing eras and today's open ecosystem, proving that code from decades past still has lessons to teach us—if we're willing to listen in the dark.

Prize Categories

Open-Source AI Integration

Most Creative / Spooky Interpretation

"Soft Start: Let Your To-Do List Exhale with Local AI"

atharvarsingh2ee-lab — Tue, 20 Oct 2026 08:21:12 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Soft Start turns an unfiltered pile of tasks into one small first step, a short optional plan, and a list of things that can wait. Pick a pace that matches your energy, paste the list you have been avoiding, and let a local model make it easier to begin.

It is for anyone who spends more energy deciding where to start than doing the first small thing. The plan is deliberately modest: stopping after the first step still counts.

Demo

There is no public deployment yet. To try it locally, install Ollama, download a model such as llama3.2:3b, then serve the project folder with python3 -m http.server 4173 and open http://localhost:4173. If the browser blocks the local model connection, follow the OLLAMA_ORIGINS note in the README.

Code

The project is a static HTML, CSS, and JavaScript app with no build step. Its source is in index.html, styles.css, and app.js; setup instructions are in README.md. A public repository link is not available yet.

How I Built It

Soft Start calls Ollama's local /api/tags endpoint to list installed models and /api/chat to generate a structured plan. The user chooses the model, and the prompt is visible and editable in app.js. Different pace settings change the guidance sent to the model, so the user can decide how ambitious the plan should be.

The app itself has no server, account, API key, analytics, external font requests, or cloud AI dependency. It sends the task list only to the Ollama service running on the same device. Once Ollama and a model are installed, inference can run offline without a per-request API charge.

The implementation was syntax-checked, but I could not exercise a live generation in this environment because Ollama and a downloaded model were not available.

Why Does Open Innovation Matter?

Task lists can contain personal details. Local inference keeps them off a hosted AI service, and offline use means the tool can still work without an internet connection after setup. Open-weight models also make the choice reversible: install a different model or adjust the prompt to change the assistant's behavior, without changing providers or rewriting the app around a closed API.

That flexibility matters here more than chasing a single benchmark. A small model that runs on your own machine can turn a stuck moment into a first step, with no subscription or usage meter attached.

Tally: A Private, Local-First Receipt Organizer

atharvarsingh2ee-lab — Tue, 13 Oct 2026 11:57:34 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Tally is a receipt and invoice organizer for freelancers and solo business owners. It reads receipt images, extracts bookkeeping details for review, saves expenses in the browser, and exports them as CSV. It aims to help people keep expense records without adding another cloud bookkeeping subscription.

The current demo supports manual entry, browser OCR, and CSV export. Local-model extraction is part of the app, but a model is not currently running in the hosted demo.

Demo

Try Tally

The demo is served from a Codespace and is available while that Codespace is running.

Code

The source files (server.py, index.html, styles.css, and app.js) are in my project workspace. I have not published a public GitHub repository yet.

How I Built It

Tally uses Tesseract.js, an open-source OCR engine, to read receipt images in the browser. For field extraction, the Python server can send recognized text to an Ollama model running locally; the setup guide suggests qwen2.5:3b. Extracted details are shown for review before saving. Expense records are stored in browser local storage.

The public demo’s Codespace does not currently have Ollama or a model running, so AI extraction is unavailable there. When run locally with Ollama, the model request stays on that machine.

Why Does Open Innovation Matter?

A hosted AI API might be easier to operate, but it can add a per-document cost and requires sending receipt text to a third party. With Ollama, a freelancer can run inference on their own machine, avoid per-receipt model fees, and switch models or adjust prompts to suit their workflow. Tesseract.js also provides OCR without uploading the receipt to a recognition service.

The tradeoff is setup: users need Ollama and a compatible model for extraction, and OCR downloads its library and language data from a CDN on first use. This public demo is a prototype, not a hosted private-inference service.

mlhacks:)

"Fieldnotes: A Local AI Garden Planner for Getting Outside"

atharvarsingh2ee-lab — Sun, 11 Oct 2026 17:30:52 +0000

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

What I Built

Fieldnotes is a browser-based garden planner that turns a few minutes of screen time into a practical reason to get outdoors. A gardener enters their region, hardiness zone, typical first frost, available growing space, and planting interests. Fieldnotes then creates a short weekend plan with manageable sowing, planting, and garden-care ideas.

I built Fieldnotes to make getting started feel approachable, whether you have a raised bed, a balcony, or just a sunny windowsill. The goal is simple: get a useful plan, then put the phone away and spend some time outside.

I’m Atharva, a student at Podar International School and an enthusiastic coder. I built this project to explore how open AI can support a small, practical habit in everyday life.

Demo

The project is currently available as a local preview at http://localhost:8000. It is not publicly deployed yet, so this address is only accessible in the development environment.

Code

The application source is in index.html in this project. This workspace is not connected to a public Git repository, so a public source-code link is not available yet.

How I Built It

Fieldnotes is built with HTML, CSS, and JavaScript. For AI, it uses the open-weight Qwen 2.5 0.5B Instruct model in quantized ONNX format, running in the browser through the open-source Transformers.js library.

The browser loads the model on the first request, then uses it to turn the gardener’s selected details into four concise suggestions. Garden details are included only in the local prompt; the app does not send them to a hosted inference API. If the model cannot be loaded, Fieldnotes clearly labels its built-in starter suggestions as a fallback.

Why Does Open Innovation Matter?

Open-weight models make it possible to run this kind of assistant on the gardener’s own device instead of sending personal details to a closed, hosted AI service. That gives people more control over their data and lets developers inspect the model setup, adjust the prompt, or replace the model as the project grows.

There is also no per-request API charge. After the app library and model have been downloaded and cached, the model’s inference can work without an internet connection. The first visit does require internet to download those assets, and the quality of its gardening suggestions still needs to be checked against local conditions.

For Fieldnotes, open innovation makes a more private and adaptable tool possible: one that can help someone decide what to do in their garden without requiring an account or a permanent connection to an AI server. The screen is only the starting point; the best part of the plan happens outside.