DEV Community: Habeeb Babasulaiman

week4 challenge

Habeeb Babasulaiman — Wed, 28 Oct 2026 00:19:17 +0000

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

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

The Spirit of It

Prize Categories

Bayān: Touch Grass with open-source AI and local Arabic reflection

Habeeb Babasulaiman — Wed, 28 Oct 2026 00:16:43 +0000

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

What I Built

Bayān is a local-first Arabic rhetoric companion that gets people off the screen and back into the world.

It turns a short outdoor walk into a focused reflective writing task. The user picks a rhetorical exercise — simile, metaphor, or sensory description — then steps away from the screen, notices a detail in the environment, and returns to turn that observation into a stronger Arabic phrase.

The experience is intentionally minimal. The app does not try to keep the user glued to a dashboard. It creates a brief, calm moment of attention, then gets out of the way.

The project is built for anyone who wants a low-friction way to practice Arabic imagery, sensory language, and thoughtful observation without needing a cloud AI service or an overly complicated interface.

Demo

GitHub repo: https://github.com/FreemanBoss/bayaan
Video recording: https://drive.google.com/file/d/1QdPSHCgWFfTDRqlc9B1euY6LShVFdhp9/view?usp=sharing
Local demo: http://127.0.0.1:8000
Project repository and usage details: https://github.com/FreemanBoss/bayaan

The project is designed to work as a real local experience: choose a prompt, step outside, notice something, come back, and write. The experience is meant to feel grounded, not like a synthetic AI showcase.

Code

Repository: https://github.com/FreemanBoss/bayaan

The codebase includes the backend, frontend, local model integration, validation logic, fallback behavior, and optional local speech/transcription support. Everything is open and easy to inspect in the public repository.

How I Built It

I built Bayān around open-weight local AI, not closed cloud APIs.

The project uses:

Ollama with Gemma 3 4B for mission generation, translation, and chat
FastAPI for the backend service layer
a lightweight static web frontend for the game flow
browser-local storage for lightweight game state
optional local Piper speech synthesis for Arabic playback
optional local Whisper transcription for voice-note input

The important design choice was that the app stays local-first. The user experience is built around the assumption that the walk happens outside the app, not inside it. The model is there to support reflection and language, not to dominate the interaction.

The app also includes validation and fallback behavior so that if the local model is unavailable or returns weak output, the user still receives a coherent experience instead of a broken UI.

Why Does Open Innovation Matter?

Open innovation matters here because the app is meant to work in the real world, not just in a cloud lab.

A closed API would not fit the spirit of the project. The app is designed for:

offline or low-connectivity outdoor use
privacy by default
local model control
transparent behavior and editable prompts
a system that can be understood, run, and improved without vendor lock-in

This project is especially relevant to the challenge because it uses open models to create a useful, grounded experience in a real-world setting. The model does not replace the user’s attention; it supports their attention. That is the meaningful difference.

My Agent Session

This project was built with a local AI-assisted workflow grounded in real runtime checks, not a fake “it works” claim.

I validated the app by:

running the backend locally
checking the live frontend
testing the API routes
validating the local speech and transcription flow
confirming the fallback behavior under real runtime conditions

The build process emphasized verification over hype: if the app did not run, it was not treated as finished.

Prize Categories

Touch Grass
Best Use of Gemma

This project fits the core Touch Grass theme directly: it is a local-first, real-world, attention-returning app built around stepping away from the screen and noticing the world.

It also uses Gemma as a core part of the product, which makes Best Use of Gemma a natural fit.

I Built Riwaya to Make Arabic Oral-History Recordings Easier to Preserve and Search

Habeeb Babasulaiman — Wed, 28 Oct 2026 00:12:56 +0000

published: true
tags: devchallenge, hf26challenge, arabic, opensource
ai_disclosure_level: some_ai

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

What I Built

I built Riwaya (رِواية), a local-first oral-history workbench that helps a researcher or community archivist turn a short Arabic recording into a time-coded, searchable, human-reviewable record.

The repetitive part of oral-history work is easy to underestimate. A custodian may listen to the same recording several times to type a first transcript, add timestamps, find a phrase later, identify topics, and prepare notes for review. Riwaya is designed to make that first pass less laborious without treating a person's voice as disposable input or presenting a model's guess as a verified historical record.

For this demonstration, I used [TODO: identify the actual recording source, such as “a short recording of my own voice”]. After importing it, Riwaya [TODO: describe only the workflow that actually works: e.g., generated timestamped transcript segments with the local ASR model, let me correct them, then produced a source-linked finding aid]. I could review a segment against the original audio, correct the wording, mark an unclear span, and export [TODO: actual export format].

The project is deliberately careful about what “Arabic” means in a recording. It keeps the raw model transcript separate from the corrected transcript and any optional translation or normalization. The speaker's variety is [TODO: state how the app records this; use “speaker-described” or “unknown” if appropriate] rather than something an AI system silently decides on the speaker's behalf.

Demo

**Working demo or video:

In the demo, show one complete short workflow:

Import the permitted audio sample.
Run the actual local transcription model and show its name/version.
Play a segment while viewing its timestamp and draft transcript.
Correct or mark one transcript segment as unclear.
Generate a finding-aid suggestion and show the linked source segment.
Accept or reject the suggestion and export the record.

**Recording note:

Code

**Public repository:

The repository should include the runnable source, dependency/model setup, tests, a license, and a sample workflow that does not expose a private recording. Do not commit audio, model weights, API keys, credentials, or other private material unless you have the necessary rights and a clear reason.

How I Built It

Riwaya separates model proposals from the archival record so that a human can inspect and correct each step.

**Audio transcription:

Human review: Each segment keeps its time range, raw ASR text, corrected text, review state, and language-variety label. The person reviewing the recording can preserve the speaker's wording, identify an uncertain span, and decide whether a proposed correction is acceptable.

Finding aid: [TODO: describe actual local open-weight model and runtime]. Given the reviewed transcript, the model proposes a short summary, a few topic labels, and candidate names or terms to verify. Each suggestion must identify the transcript segment it came from. Application code validates that the cited segment exists; a valid citation is not treated as proof that the interpretation is correct.

Export and search: [TODO: state the actual storage and export format]. The export keeps the audio reference, transcript variants, timestamps, review state, and accepted finding-aid fields together so another person can see what was machine-generated and what a human changed.

Actual stack: Python, FastAPI/Streamlit, faster-whisper, Ollama/Gemma, SQLite/JSON

Architecture:

flowchart LR
    A[Permitted audio recording] --> B[Local speech recognition]
    B --> C[Timestamped draft transcript]
    C --> D[Human edits and uncertainty markers]
    D --> E[Local open-weight language model]
    E --> F[Candidate finding aid with source segment IDs]
    F --> G[Application validates IDs and schema]
    G --> H[Human accepts or rejects suggestions]
    H --> I[Portable reviewed archive record]

Tests and evaluation: [TODO: list the tests that actually pass]. I evaluated the prototype on [TODO: duration and description of the permitted test clip]. Local inference took [TODO: measured time or “not measured”]; human review took [TODO: measured time or “not measured”]. The main errors I observed were [TODO: honest examples, or state that no quality evaluation beyond this demo was conducted]. This is a small prototype test, not a claim about performance across Arabic dialects or oral-history archives generally.

Why Does Open Innovation Matter?

A voice recording can contain personal, family, community, or culturally restricted material. For that reason, I wanted the core inference in this prototype to run on the custodian's own machine rather than requiring them to upload a recording to a hosted AI service.

Using an open-weight model locally gives the builder and custodian more control over where inference runs, which model is selected, and how the workflow is inspected or adapted. It also makes it possible to design the product around preservation choices: keep the original audio, retain the first model transcript, record human corrections separately, and make AI-generated descriptions traceable to source segments.

That does not make the tool automatically ethical or accurate. A local model can still mishear dialect, normalize a speaker's wording, miss a name, or invent an interpretation. Local inference is not a replacement for informed consent, careful access decisions, or human listening. Riwaya therefore treats model output as a proposal for a human archivist to review, not as an authoritative transcript or a substitute for oral-history practice.

Privacy implementation: [TODO: state what you verified. For example, whether the app binds to localhost, whether any remote requests occur, and whether the recording is saved or deleted]. Do not say “offline” unless you tested the complete workflow after model downloads with the network disconnected. If you only verified local inference, say “local inference.”

The Slow and Steady Payoff

Riwaya aims to replace a blank page and repeated manual timestamping with a draft that a person can check against the original audio. The human still does the important work: listening, correcting, deciding what is uncertain, and choosing what belongs in the archive. The model handles a repetitive first pass; the person retains editorial control.

Consent, Preservation, and Limits

Riwaya is a prototype, not a certified archival system. The first version is intentionally narrow: [TODO: name supported audio format, tested language variety, maximum clip length, and any hardware requirements].

Before recording or processing another person's voice, I explain what the prototype does and obtain permission for the specific use. Permission to process a recording is not automatically permission to publish it. The speaker should be able to choose attribution, pseudonym, or no public attribution, and should know whether audio, transcript, or summaries may be shared.

AI disclosure: This article was drafted with meaningful AI assistance. I reviewed it and remain responsible for the accuracy of its claims.

I Built Riwaya to Make Arabic Oral-History Recordings Easier to Preserve and Search

Habeeb Babasulaiman — Wed, 28 Oct 2026 00:04:03 +0000

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

What I Built

Demo

**Working demo or video:

In the demo, show one complete short workflow:

Import the permitted audio sample.
Run the actual local transcription model and show its name/version.
Play a segment while viewing its timestamp and draft transcript.
Correct or mark one transcript segment as unclear.
Generate a finding-aid suggestion and show the linked source segment.
Accept or reject the suggestion and export the record.

**Recording note:

Code

**Public repository:

How I Built It

Riwaya separates model proposals from the archival record so that a human can inspect and correct each step.

**Audio transcription:

Actual stack: Python, FastAPI/Streamlit, faster-whisper, Ollama/Gemma, SQLite/JSON

Architecture:

flowchart LR
    A[Permitted audio recording] --> B[Local speech recognition]
    B --> C[Timestamped draft transcript]
    C --> D[Human edits and uncertainty markers]
    D --> E[Local open-weight language model]
    E --> F[Candidate finding aid with source segment IDs]
    F --> G[Application validates IDs and schema]
    G --> H[Human accepts or rejects suggestions]
    H --> I[Portable reviewed archive record]

Why Does Open Innovation Matter?

The Slow and Steady Payoff

Consent, Preservation, and Limits

AI disclosure: This article was drafted with meaningful AI assistance. I reviewed it and remain responsible for the accuracy of its claims.

Bayān: Touch Grass with open-source AI and local Arabic reflection

Habeeb Babasulaiman — Mon, 12 Oct 2026 07:27:14 +0000

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

What I Built

Bayān is a local-first Arabic rhetoric companion that gets people off the screen and back into the world.

The experience is intentionally minimal. The app does not try to keep the user glued to a dashboard. It creates a brief, calm moment of attention, then gets out of the way.

Demo

GitHub repo: https://github.com/FreemanBoss/bayaan
Video recording: https://drive.google.com/file/d/1QdPSHCgWFfTDRqlc9B1euY6LShVFdhp9/view?usp=sharing
Local demo: http://127.0.0.1:8000
Project repository and usage details: https://github.com/FreemanBoss/bayaan

Code

Repository: https://github.com/FreemanBoss/bayaan

How I Built It

I built Bayān around open-weight local AI, not closed cloud APIs.

The project uses:

Ollama with Gemma 3 4B for mission generation, translation, and chat
FastAPI for the backend service layer
a lightweight static web frontend for the game flow
browser-local storage for lightweight game state
optional local Piper speech synthesis for Arabic playback
optional local Whisper transcription for voice-note input

The app also includes validation and fallback behavior so that if the local model is unavailable or returns weak output, the user still receives a coherent experience instead of a broken UI.

Why Does Open Innovation Matter?

Open innovation matters here because the app is meant to work in the real world, not just in a cloud lab.

A closed API would not fit the spirit of the project. The app is designed for:

offline or low-connectivity outdoor use
privacy by default
local model control
transparent behavior and editable prompts
a system that can be understood, run, and improved without vendor lock-in

My Agent Session

This project was built with a local AI-assisted workflow grounded in real runtime checks, not a fake “it works” claim.

I validated the app by:

running the backend locally
checking the live frontend
testing the API routes
validating the local speech and transcription flow
confirming the fallback behavior under real runtime conditions

The build process emphasized verification over hype: if the app did not run, it was not treated as finished.

Prize Categories

Touch Grass
Best Use of Gemma

This project fits the core Touch Grass theme directly: it is a local-first, real-world, attention-returning app built around stepping away from the screen and noticing the world.

It also uses Gemma as a core part of the product, which makes Best Use of Gemma a natural fit.

Beyond Grammar: I Built Meydan to Help My Friends Use Arabic in Their Fields

Habeeb Babasulaiman — Mon, 05 Oct 2026 07:01:33 +0000

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

What I Built

I built ميدان (Meydan), a bilingual Arabic and English writing and practice studio for people who know their field but struggle to express that knowledge in Arabic.

I studied Arabic and Transnational Studies, and I also work across software engineering, DevOps, and cloud infrastructure. I could discuss much of my technical work in English, but found it difficult to explain the same ideas naturally in Arabic. Friends studying Arabic described a similar gap: they were learning grammar and conversation, yet still lacked practice using Arabic to discuss their studies, work, and interests.

That gap became more concrete when I shared the early version of Meydan with friends. They tried it, responded positively, and asked when they could use it online instead of on my computer. Their response encouraged me, while also making the next challenge clear: before opening it up more widely, I need to improve speed, review the Arabic with qualified speakers, and make the experience reliable enough for regular use.

Meydan starts with four fields: technology, health communication, travel, and international relations. A learner can ask it to write about a subject in Arabic and provide an English translation, build a bilingual field glossary with example sentences, or practise a realistic dialogue. They can switch the interface between Arabic and English, choose a light or dark theme, and save useful terms in a phrasebook on their device.

Demo video: https://drive.google.com/file/d/1ZpLdC_UuxUTbUPsC48zPLZnT_CCSRoZA/view?usp=drive_link

Meydan gives them a practical bridge from knowledge to communication.

A learner can:

Ask Meydan to write about a topic in Arabic.
Receive an English translation and useful Arabic terminology.
Learn field-specific vocabulary for technology, health communication, travel, and international relations.
Practise realistic professional conversations.
Save useful expressions in a local phrasebook.
Switch the interface between Arabic and English.
Switch between light and dark themes.

The first use case I built around is this kind of request:

Demo

Demo video: https://drive.google.com/file/d/1ZpLdC_UuxUTbUPsC48zPLZnT_CCSRoZA/view?usp=drive_link

The demo shows the Arabic-first interface, the writing workflow, the bilingual response, the terminology cards, the English interface, dark mode, and the local model status.

The model runs locally through Ollama, so the demo may take longer to respond than a hosted GPU service. The application streams the response as it is generated instead of waiting silently for the entire answer.

Code

View the Meydan repository on GitHub

How I Built It

Meydan is a React, TypeScript, and Vite application with an Arabic-first RTL interface and an English LTR mode.

The core architecture is:

flowchart LR
    Learner[Arabic learner] --> UI[React bilingual interface]
    UI --> Proxy[Vite local Ollama proxy]
    Proxy --> Ollama[Ollama on localhost]
    Ollama --> Gemma[Gemma 3 4B open-weight model]
    UI --> Phrasebook[Browser-local phrasebook]

The current local model is Gemma 3 4B, served through Ollama. The app sends requests to the local Ollama service rather than to a hosted model API. Responses stream into the interface and are rendered as structured Markdown so longer Arabic writing, translations, lists, and terminology tables remain readable.

I designed three focused workflows instead of one generic chatbot:

Write an idea: produce Arabic writing, English translation, and key vocabulary.
Learn terminology: create a focused bilingual glossary with examples.
Practise a dialogue: simulate a realistic conversation in a selected field.

The application also includes:

Arabic/English interface switching.
Light/dark mode persistence.
Field-specific starter terminology.
A local phrasebook stored in browser storage.
Health and other high-stakes safety boundaries.
A clear local-model status indicator.

I tested the project on a machine with 12 CPU cores, 32 GB RAM, and integrated graphics. No hosted model API is required for the prototype.

Why Does Open Innovation Matter?

Open innovation matters because language practice can contain private, unfinished, and personal ideas. A learner should be able to practise describing their work without automatically sending every message to a remote service they do not control.

With local inference, Meydan can run on the learner's own machine through Ollama. This makes several things possible:

The learner's practice messages can stay local.
The model choice and runtime are visible and replaceable.
The application can be inspected and modified.
The project does not require a paid hosted AI API for its core workflow.
The model can be evaluated against the actual Arabic tasks the learner cares about.

Open AI also makes the limitations visible. On my CPU-only machine, Gemma 3 4B is not instant. A 371-token test took approximately 110 seconds end-to-end. The interface therefore streams output as it arrives and keeps responses bounded. The model can also produce fluent but imperfect Arabic, so the application clearly presents itself as a practice aid rather than an authority.

That trade-off is part of the project: privacy and inspectability are valuable, but they do not remove the need for human language review.

What I Learned

The most important lesson was that multilingual support cannot be evaluated by fluency alone.

A model may produce beautiful Arabic while choosing the wrong technical term, adding an unintended metaphor, or translating a professional phrase too literally. I tested the same kind of task across models and found that a smaller model can be faster without automatically being more accurate.

The practical solution is to evaluate the actual task:

Can it preserve the learner's intended meaning?
Does it produce natural Modern Standard Arabic?
Are the field-specific terms correct?
Does it handle English-Arabic code-switching?
Does it avoid inventing facts?

I still need a fluent Arabic reviewer to evaluate the terminology and my friend's real feedback before treating the output as polished language instruction.

Prize Categories

I am entering:

Best Use of Gemma

Gemma is used as the core local model for writing, terminology, and practice responses. It is not included as a decorative or incidental integration.

Project Status

This is a new prototype built during the challenge window. The repository is public and licensed under MIT:

The project is intentionally honest about its limits: local CPU inference is slow, Arabic output needs review, and the health workflow is communication practice only, not medical advice.

Thank you to the DEV and MLH teams for creating a challenge that encouraged me to build something personal and useful for someone I care about.