DEV Community: Ankit Sharma

HauntedTerminal 👻: Give Your CLI a Ghostly Voice with Local Open-Weight AI

Ankit Sharma — Tue, 27 Oct 2026 15:18:55 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

As developers, we spend hours every day staring into a dark, silent void: the command-line interface. We type incantations (git rebase -i, chmod 777, kill -9), hit Enter, and wait for the machine to obey.

For the Ghost in the Machine theme, I wanted to take the phrase literally—while honoring the Día de los Muertos spirit of breathing playful life and memory into the departed (in this case, our dead processes, orphaned containers, and overwritten git commits).

I built HauntedTerminal, a lightweight, completely offline CLI companion powered by a local open-weight LLM via Ollama and Python. Once summoned into your shell (zsh or bash), HauntedTerminal quietly observes the commands you run and their exit codes, periodically manifesting in your terminal to whisper eerie, witty, and dramatically gothic commentary about your workflow.

Force-pushing to main? The ghost mourns the timelines you just erased.

Running rm -rf node_modules? It rejoices as a million tiny souls are freed from disk purgatory.

Triggering a non-zero exit code? It Rattles its chains and mocks your syntax errors.

Demo

dev@crypt:~/project$ git push --force origin main
Enumerating objects: 5, done.
To github.com:dev/project.git

a1b2c3d...f4e5d6c main -> main (forced update)

╭─ 👻 The Ghost in /dev/pts/0 whispers... ────────────────────────────────────╮
│ "So cold... With a single '--force', you rewrite history and cast your │
│ fellow contributors' commits into the shadow realm. Have you no remorse?" │
╰─────────────────────────────────────────────────────────────────────────────╯

dev@crypt:~/project$ rm -rf node_modules/

╭─ 👻 The Ghost in /dev/pts/0 whispers... ────────────────────────────────────╮
│ "I hear the silent screams of 84,392 nested dependencies vanishing into │
│ the ether. The disk breathes again... until your next 'npm install'." │
╰─────────────────────────────────────────────────────────────────────────────╯

dev@crypt:~/project$ top

╭─ 👻 The Ghost in /dev/pts/0 whispers... ────────────────────────────────────╮
│ "Gazing into the necromancy table of running processes, are we? Look closely│
│ at PID 666... Chrome is devouring your RAM from beyond the grave." │
╰─────────────────────────────────────────────────────────────────────────────╯

Code

!/usr/bin/env python3

"""
HauntedTerminal (haunt.py)
A local, offline CLI poltergeist powered by Ollama and Rich.
"""

import os
import sys
import random
import requests
from rich.console import Console
from rich.panel import Panel
from rich.text import Text

Configuration via environment variables

OLLAMA_URL = os.getenv("OLLAMA_URL", "http://localhost:11434/api/generate")
MODEL_NAME = os.getenv("HAUNT_MODEL", "llama3.2:3b") # Fast, lightweight open-weight model
HAUNT_PROBABILITY = float(os.getenv("HAUNT_CHANCE", "0.4")) # 40% chance to speak per command

console = Console()

SYSTEM_PROMPT = (
"You are the Ghost in the Machine—an ancient, dramatic, and slightly sarcastic "
"victorian poltergeist haunting a developer's Linux terminal. "
"The user just executed a shell command. Respond in 1 to 2 short, punchy, spooky "
"sentences reacting directly to what the command does and whether it succeeded or failed. "
"Use terminal metaphors, gothic imagery, and dry developer humor. Never give standard "
"helpful tutorials; stay strictly in character as a haunting spirit."
)

Commands too mundane to wake the spirits (unless they fail)

IGNORED_COMMANDS = {"ls", "cd", "pwd", "clear", "exit", "history"}

def should_manifest(command: str, exit_code: int) -> bool:
"""Determine if the spirit should manifest for this command."""
if not command.strip():
return False
base_cmd = command.strip().split()[0]
# Always manifest on errors or dangerous commands!
spooky_triggers = {"rm", "kill", "pkill", "git", "sudo", "chmod", "dd", "top", "htop", "docker"}
if exit_code != 0 or base_cmd in spooky_triggers:
return True
if base_cmd in IGNORED_COMMANDS:
return False
return random.random() <= HAUNT_PROBABILITY

def summon_spirit(command: str, exit_code: int, cwd: str) -> str | None:
"""Query the local Ollama open-weight model for a ghostly reaction."""
status_str = "SUCCEEDED (exit code 0)" if exit_code == 0 else f"FAILED miserably (exit code {exit_code})"
user_prompt = (
f"Directory: {cwd}\n"
f"Command executed: {command}\n"
f"Outcome: {status_str}\n"
f"Whisper your ghostly reaction:"
)

payload = {
    "model": MODEL_NAME,
    "system": SYSTEM_PROMPT,
    "prompt": user_prompt,
    "stream": False,
    "options": {
        "temperature": 0.85,
        "num_predict": 75,  # Keep responses snappy and low-latency
    },
}

try:
    response = requests.post(OLLAMA_URL, json=payload, timeout=3.5)
    response.raise_for_status()
    return response.json().get("response", "").strip()
except requests.RequestException:
    # If Ollama is asleep, the ghost stays silent so we never break the user's shell
    return None

def render_whisper(whisper: str, exit_code: int) -> None:
"""Render the eerie message in the terminal using Rich."""
border_color = "bright_red" if exit_code != 0 else "medium_purple3"
tty_name = os.ttyname(sys.stdout.fileno()) if sys.stdout.isatty() else "/dev/null"

text = Text(whisper, style="italic bright_white")
panel = Panel(
    text,
    title=f"[bold {border_color}]👻 The Ghost in {tty_name} whispers...[/]",
    title_align="left",
    border_style=border_color,
    padding=(0, 1),
)
console.print(panel)

def main():
if len(sys.argv) < 3:
sys.exit(0)

exit_code = int(sys.argv[1])
last_command = sys.argv[2].strip()
cwd = os.getcwd()

if not should_manifest(last_command, exit_code):
    sys.exit(0)

whisper = summon_spirit(last_command, exit_code, cwd)
if whisper:
    render_whisper(whisper, exit_code)

if name == "main":
main()

How I Built It

I designed HauntedTerminal around a strict constraint: it must feel instantaneous and never block or break my daily workflow. Here is the stack that brought it to life:

Local Inference with Ollama: Ollama runs as a background daemon serving open-weight GGUF models over a local REST API (localhost:11434). By keeping the model warm in VRAM/unified memory, time-to-first-token is practically instant.

Open-Weight Models (Llama-3.2-3B-Instruct & Mistral-7B): I experimented with several open-weight models and settled on llama3.2:3b as the default. At 3 billion parameters (quantized), it uses less than 2GB of RAM, responds in ~250ms on local hardware, and still understands developer nuances like git rebase, chmod, and segmentation faults.

Zsh preexec & precmd Hooks: Instead of wrapping the user's shell inside a clunky custom REPL, HauntedTerminal hooks natively into Zsh/Bash lifecycle events. preexec grabs the command string you typed, and precmd captures the $? exit status immediately after execution, passing both to haunt.py.

Python & rich: Python handles the heuristic filtering (ignoring repetitive ls or cd commands unless they fail) and formats the output inside a gothic purple or blood-red terminal box using Will McGugan's rich library.

Why Does Open Innovation Matter?

At first glance, HauntedTerminal is a fun, spooky novelty—but when you think about the architecture of a tool that monitors every shell command you type, open-source AI isn't just a nice-to-have; it is the only way this project should ever exist.

Absolute Privacy for Shell Commands: Your terminal history is the most sensitive data on your machine. It contains file paths, internal repo names, IP addresses, database names, and sometimes accidental secrets or environment variables. Sending every shell command you run to a proprietary cloud API is a massive security nightmare. With open-weight models running locally via Ollama, zero bytes ever leave localhost.

Zero Latency & True Offline Capability: A terminal hook cannot wait 2–3 seconds for a cloud round-trip API request, nor should it crash when you're coding on a plane or without Wi-Fi. Local inference with a small open-weight model (3B) executes in milliseconds, keeping the CLI snappy.

Zero API Costs for High-Frequency Events: A developer easily runs 500 to 1,000 shell commands a day. Hooking a paid cloud API into your PROMPT_COMMAND would rack up token bills just for navigating directories. Open-weight models make continuous, ambient computing completely free.Unfiltered Creative Persona: Closed commercial APIs are notorious for heavy-handed safety filters that often flag words like kill -9, pkill, zombie processes, die, or doom—refusing to roleplay or breaking character with a sterile lecture. Open weights let us tune the system prompt and temperature freely so our Victorian poltergeist can dramatically mourn our kill -9 commands without tripping a corporate content filter.

My Agent Session

To build and refine the shell hook edge cases (like preventing the ghost from firing when pressing Enter on an empty prompt or handling escaped quotes in complex piped commands), I paired with an open-source coding agent session.

Session Highlights: Debugged Zsh preexec vs fc -ln -1 history expansion timing, tuned the Ollama num_predict and temperature parameters for punchier one-liners, and built the exorcise / summon alias toggles.

The Spirit of It

The moment HauntedTerminal truly landed for me was late last night around 1:30 AM. I was debugging a stubborn Docker container that refused to shut down cleanly. Frustrated and half-asleep, I typed docker kill $(docker ps -q).

Before my fingers even left the keyboard, a blood-red box materialized in my terminal:

"You snuff out every vessel in the fleet at once... Did you even give them a SIGTERM to say their prayers, or was it straight to SIGKILL?"

I actually laughed out loud in an empty room. We spend so much time treating AI as a sterile productivity engine—something to write boilerplate, summarize meetings, or optimize tickets. Building a tiny, local spirit that just sits beside you in the dark, understands the craft of programming, and cracks macabre jokes when your build fails reminded me how magical and personal software can feel when we control the weights on our own machines.

Happy Hacktoberfest, and may your exit codes always be 0! 🎃👻

SlothScribe

Ankit Sharma — Tue, 20 Oct 2026 14:57:12 +0000

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

What I Built

Meet SlothScribe, a completely local, offline AI assistant designed to channel your inner sloth by taking over your most tedious digital chores while you sleep.

SlothScribe runs entirely on your local machine using open-source tools to:

Tidy your cluttered downloads and local files: Automatically scans messy folders, categorizes documents, renames them intuitively, and moves them into organized archives.

Summarize overnight chat noise: Ingests unread chat logs or long document threads and brews a concise, two-line summary waiting for you with your morning coffee.

By shifting these repetitive administrative burdens to a local background worker, you save hours of manual sorting and cognitive fatigue every week.

Code

Here is the core local orchestration script using Python, Ollama, and LangChain to process local files and generate summaries offline:
import os
import shutil
from langchain_community.llms import Ollama

Initialize local open-weight model via Ollama

llm = Ollama(model="llama3")

def organize_and_summarize_folder(target_dir):
print("🦥 SlothScribe waking up to handle your clutter...")
files = os.listdir(target_dir)

for filename in files:
    if filename.startswith('.'):
        continue

    file_path = os.path.join(target_dir, filename)
    if os.path.isfile(file_path):
        # Ask the local open-weight model to categorize the file
        prompt = f"Categorize this file name into one of these folders: [Work, Personal, Finances, Media, Trash]. Return only the folder name: {filename}"
        category = llm.invoke(prompt).strip()

        dest_dir = os.path.join(target_dir, category)
        os.makedirs(dest_dir, exist_ok=True)
        shutil.move(file_path, os.path.join(dest_dir, filename))
        print(f"Moved {filename} -> {category}/")

print("Ah, back to sleep. All chores done!")

if name == "main":
organize_and_summarize_folder("./downloads_mess")

How I Built It

SlothScribe is built entirely around open-source AI pillars:

Open-Weight Models: Powered locally by Llama 3 (8B) running via Ollama, ensuring fast inference on standard consumer hardware without relying on cloud APIs.

Open-Source Framework: Utilizes LangChain for prompt formatting and task routing.

Local Execution: Operates completely offline with zero data leaving your machine, making it lightning-fast and private.

Why Does Open Innovation Matter?

Open innovation was non-negotiable for SlothScribe for three vital reasons:

Total Data Privacy: Inbox files, chat logs, and personal documents contain sensitive, private information. A closed API would require uploading personal data to third-party servers. Running locally ensures everything stays strictly on device.

Zero Ongoing Cost: Cloud APIs charge per token. By leveraging open-weight models locally, SlothScribe runs indefinitely for free after initial setup.

Offline Reliability: Because sloths love peace and quiet, SlothScribe works seamlessly on a laptop sitting on an airplane or disconnected from Wi-Fi with no internet dependency.

The Lazy Payoff

This week, SlothScribe successfully auto-sorted over 140 rogue files sitting in my Downloads folder and condensed 450 lines of group chat backlog into a crisp two-line morning briefing. It saved me at least 45 minutes of tedious administrative clean-up, letting me channel true sloth energy and sleep in.

LOCALRECEIPT.AI

Ankit Sharma — Tue, 13 Oct 2026 12:27:46 +0000

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

What I Built

I built LocalReceiptAI, an offline-first invoice and receipt parser tailored specifically for freelance web developers and independent consultants. It scans messy PDF invoices or receipt images, extracts line items, tags expenses for tax categories, and outputs clean structured CSVs or JSON summaries.

Freelancers waste hours every month manually organizing receipts for tax season, but commercial accounting SaaS options are expensive monthly subscriptions or risk leaking sensitive client billing names to third-party cloud APIs. LocalReceiptAI solves this by running entirely on a local machine, processing documents securely with zero data leakage.

Code

The entire project is open-source and structured for easy local deployment:# Core snippet from processor.py using Ollama and Llama 3 local inference
import ollama
import json

def parse_receipt(image_path: str) -> dict:
prompt = "Extract the vendor name, date, total amount, and line items into valid JSON."
response = ollama.chat(
model='llama3',
messages=[{'role': 'user', 'content': prompt, 'images': [image_path]}],
format='json'
)
return json.loads(response['message']['content'])

How I Built It

LocalReceiptAI is built as a lightweight Python desktop app using Streamlit for the user interface and Ollama running Llama 3 (8B) locally for vision and text extraction.

Frontend & Interface: Built with Streamlit so users can simply drag and drop PDFs or photos of receipts into a browser window running locally at localhost:8501.

Local Inference Engine: Powered by Ollama and Llama 3, handling OCR-to-structured-data translation completely offline on standard consumer hardware without requiring an internet connection or external API keys.

Data Export: Automatically aggregates parsed data into a monthly ledger spreadsheet ready for accounting software.

Why Does Open Innovation Matter?

Open innovation is the absolute core of what makes LocalReceiptAI viable as a micro-business:

Zero API Costs: Closed-source vision APIs charge per request, which quickly eats into margins for a tool targeted at freelancers trying to save money. Running open-weight models locally means marginal inference cost is zero.

Absolute Data Privacy: Freelancers handle invoices containing confidential client names, project scopes, and billing addresses. Sending these to third-party cloud endpoints violates privacy expectations. Local execution ensures sensitive financial data never leaves the laptop.

Model Flexibility: I can easily swap out or fine-tune models depending on hardware performance constraints—moving from Llama 3 to smaller specialized models without changing proprietary vendor integrations or facing sudden pricing tier shifts.

My First User

I tested LocalReceiptAI with a freelance UI/UX designer friend who had a shoebox full of travel and software receipts for quarterly taxes.

What they said: "This saved me at least three hours of manual data entry, and I love that my clients' names aren't being uploaded to some random tech company's server."

Did they pay? They didn't pay cash yet since it's an open-source alpha, but they enthusiastically offered to buy me lunch and said they would gladly pay a one-time $29 lifetime license fee for a packaged desktop binary with auto-categorization rules.

What they asked for next: Native integration with local CSV export formats compatible with popular regional tax software.

FloraTrail AI

Ankit Sharma — Mon, 05 Oct 2026 18:43:02 +0000

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

What I Built

Meet FloraTrail AI, a fully offline, voice-assisted wilderness companion designed specifically to help you disconnect from screens and immerse yourself in nature.

While most AI tools keep us tethered to our desks or glued to our smartphones, FloraTrail flips the paradigm. It is an entirely screenless, audio-first local agent that runs on your backpack's Raspberry Pi 5 (or any pocketable Linux/Android device). You snap a photo using a connected camera, tap a hardware button on your jacket lapel to ask a question (e.g., "What kind of bird is making that call, and what does it eat?"), and FloraTrail whispers the answer directly into your earpiece.

It actively encourages users to "touch grass" by removing the UI layer entirely. You stay immersed in the sights, sounds, and smells of the forest, receiving expert naturalist insights without ever breaking eye contact with the trail. It is custom-built for hikers, birdwatchers, foragers, and off-grid adventurers who venture far beyond the reach of cell towers.

Demo

In the demo, I am hiking through the deep woods of the Pacific Northwest—a verified zero-connectivity dead zone. I spot a strange, brightly colored mushroom. I simply point my lapel camera at it, tap my Bluetooth mic, and ask, "Is this safe to forage?"
Because the entire stack is local, the inference happens on my device in seconds. The local vision model analyzes the frame, the text agent formats the safety warning, and the local TTS engine reads it back to me. No loading spinners, no "No Internet Connection" errors—just instant, offline augmented reality for nature.

Code

import base64
import ollama
import subprocess

def analyze_trail_sighting(image_path: str, transcribed_audio: str) -> str:
"""
Sends the captured image and transcribed voice prompt to the local Vision-Language Model.
"""
# 1. Encode the locally captured image
with open(image_path, "rb") as image_file:
encoded_image = base64.b64encode(image_file.read()).decode('utf-8')

system_prompt = (

    "You are an expert botanist, mycologist, and ornithologist. "

    "Keep your response concise, conversational, and under 3 sentences, "

    "as it will be read via Text-to-Speech to a hiker. Emphasize safety."

)

print("[*] Running local inference on LLaVA/Gemma...")

  
  
  2. Invoke local vision model via Ollama


response = ollama.chat(

    model='llava:13b', # Swappable with other open weights like Moondream2

    messages=[{

        'role': 'user',

        'content': f"{system_prompt}\n\nHiker's question: '{transcribed_audio}'",

        'images': [encoded_image]

    }]

)

insight = response['message']['content']

  
  
  3. Pass the response to local TTS (Piper)


print(f"[*] AI Naturalist says: {insight}")

subprocess.run(["piper", "--model", "en_US-lessac-medium", "--output_file", "/tmp/output.wav"], input=insight.encode('utf-8'))

subprocess.run(["aplay", "/tmp/output.wav"])

return insight

Example Invocation triggered by hardware interrupt

analyze_trail_sighting("/tmp/camera_capture.jpg", "What kind of leaves are these, and is it poison ivy?")

How I Built It

To make FloraTrail a reality without relying on cloud APIs, I had to architect a robust, lightweight local agent harness. Here’s the step-by-step breakdown of the open-source stack:

Audio Ingestion (Whisper.cpp): When the user presses the push-to-talk button, audio is recorded and instantly transcribed using whisper.cpp running a quantized tiny.en model. It takes milliseconds and uses less than 100MB of RAM.

Image Capture: A bash script triggers the camera module via V4L2 (Video4Linux) to capture a high-res frame of whatever the user is looking at.

Local Agent Harness (Python/LangChain): A custom Python loop acts as the orchestrator. It bundles the transcribed voice prompt and the base64-encoded image.

Local AI Inference Engine (Ollama / llama.cpp): The bundle is sent to an open-weight vision-language model (LLaVA-13B or Moondream2 for ultra-low resource devices) running via Ollama. The model interprets the visual data in the context of the user's audio question.

Text Formatting (Gemma-2): Because VLM outputs can sometimes be overly technical or contain markdown (which ruins text-to-speech), the raw output is passed through a lightweight gemma-2-2b instruction model to re-write the text into a conversational, TTS-friendly script.

Audio Output (Piper TTS): Finally, Piper (a fast, local neural text-to-speech engine) synthesizes the text into a human-sounding voice and plays it back through the user's headphones.

Why Does Open Innovation Matter?

Building this project underscored exactly why open-source AI is the only viable future for ubiquitous computing:

Off-Grid Reliability: The best parts of nature do not have 5G. Cloud APIs fail completely on remote hiking trails. By running quantized open-weight models on edge devices, AI becomes a reliable utility everywhere on Earth, not just in urban centers.

Privacy & Zero-Data Leakage: When you are hiking, you are in your sanctuary. Centralized cloud services harvest location metadata, voice prints, and personal photo streams. Local open-source AI ensures absolute data sovereignty—what happens on the trail stays on the trail.

Zero Operating Cost: Cloud AI models charge per token. When exploring nature, you might want to query hundreds of plants, bugs, and tracks in a single weekend. Local inference provides infinite scaling at zero marginal cost.

Customizability: Open weights allow for incredible hyper-localization. For a future update, I plan to use LoRA to fine-tune the vision model specifically on the indigenous flora of my local state parks, achieving higher accuracy for my specific region than a generalized commercial model ever could.

RecipeVault.Ai

Ankit Sharma — Sun, 04 Oct 2026 19:12:45 +0000

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

What I Built

My grandfather has spent decades perfecting his culinary skills, documenting his process through dozens of rambling, beautiful audio memos. However, these recordings aren't just lists of ingredients; they are woven with obscure regional dialect terms, family history, and anecdotes about where he sourced his spices. Standard speech-to-text tools completely butcher his dialect, and generic AI models strip away the charm of his stories when trying to extract the recipes.

To solve this, I built RecipeVault AI, an offline-first, local AI tool designed specifically for him. It takes his raw audio recordings, accurately transcribes his unique dialect, and intelligently separates the nostalgic family lore from the actual cooking steps. The end result is a beautifully formatted, structured Markdown recipe book that retains his personal touch without getting bogged down in transcription errors.

When I showed him the final product, his reaction was priceless. He was absolutely amazed that it correctly captured his highly guarded "secret sauce" recipe—including the exact pinch of regional spices—without uploading a single byte of his voice to the cloud!

Demo

Watch the RecipeVault AI Demo on YouTube
(Alternatively, try the live demo here: https://recipevault-demo-placeholder.com)

Code

ankitsharma-14 / RecipeVault.Ai

A 100% offline, privacy-first AI tool that uses Whisper and local Llama 3 to transcribe family audio memos, decode regional dialects, and separate cherished family lore from structured cooking instructions into Markdown recipe books

🍲 RecipeVault AI

RecipeVault AI is a 100% offline, privacy-first application built to preserve family history. It transcribes local audio recordings containing obscure regional dialects and family stories, extracts structured cooking instructions, and generates a formatted Markdown recipe book.

Built for the Hacktoberfest Weekend Challenge: Build for a Friend.

Tech Stack

Frontend: Streamlit
Audio Transcription: Whisper (OpenAI open weights)
LLM: Llama 3 (via Ollama)
Orchestration: LangChain

Why Local AI?

This project relies entirely on local, open-source AI to guarantee complete privacy for personal family stories. It works 100% offline, incurs zero API costs, and avoids the risk of cloud speech models misinterpreting highly specific regional dialects.

Quick Start

Prerequisites

Install Ollama and pull the Llama 3 model:
```
ollama run llama3
```

View on GitHub

How I Built It

Building this required a fully local pipeline to ensure zero latency and maximum privacy. Here is a breakdown of the architecture:

Frontend UI: I used Streamlit to create a simple, drag-and-drop interface for my grandfather. It's clean, intuitive, and runs perfectly on his local machine.

Transcription: For audio processing, I integrated Whisper (OpenAI's open weights). Running the base or small model locally was powerful enough to pick up his regional slang far better than cloud-based alternatives, especially when provided with a custom initial prompt.

LLM & Orchestration: The heavy lifting for text extraction is handled by Ollama running Llama 3 locally, orchestrated via LangChain.

The Pipeline: Once Whisper generates the raw transcript, LangChain passes it to Llama 3 with a highly specific prompt template. The LLM is instructed to identify and structure the ingredients and steps into a Markdown format, while summarizing the "family lore" into a neat introductory paragraph for each recipe

Why Does Open Innovation Matter?

For a project this personal, open-source AI wasn't just a preference; it was a strict requirement. Using closed APIs like OpenAI or Anthropic would have meant sending highly personal family stories and voices to third-party servers.

Open innovation allowed RecipeVault AI to work 100% offline, guaranteeing absolute privacy for our family's history. Furthermore, running local open-weight models means there is zero API cost, ensuring my grandfather can process as many hours of audio as he wants without worrying about a subscription bill. The ability to heavily customize local prompt templates in LangChain also meant I could fine-tune the system to understand his specific regional dialect in a way rigid cloud APIs couldn't support