Deen Trace

Aiman Fazal — Tue, 06 Oct 2026 18:37:49 +0000

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

What I Built

Deen Trace — an AI that knows when to get out of your way.

Deen Trace is a concept/prototype for a private, offline-first Muslim activity journal built around one simple principle:

Log → Reflect → Leave the screen.

The idea is to let people record everyday activities such as Salah, Qur'an, Dhikr, Sadaqah, Good Deeds, and Fasting, then review their history through a simple visual activity graph.

But the feature I designed specifically for Touch Grass is called Step Outside.

Instead of using AI to keep someone talking to an app, Deen Trace uses a local open-weight model to look at activity patterns and generate a small, non-judgmental suggestion for something the user can do away from the screen.

For example:

Step Outside

Put your phone down.

Take a short walk.

Notice something you normally overlook.

And then the app gets out of the way.

There are no outdoor streaks, XP, leaderboards, badges, or engagement loops.

The app doesn't even need to know whether the user followed the suggestion.

The goal is for the screen to be the shortest part of the experience.

Demo

This submission is currently a prototype/concept implementation plan rather than a deployed application.

The intended demo flow is:

Record daily activity.
View the activity graph.
Turn Wi-Fi/mobile data off.
Generate a reflection using the local AI model.
Receive a personalized "Step Outside" suggestion.
Put the phone down and actually go outside.

The most important moment of the demo would be generating the reflection while completely offline.

Code

The project is designed as an open-source application with the following architecture:

deentrace/
├── presentation/
├── domain/
├── data/
├── ai/
└── core/

The local database is the source of truth for the device.

The application is designed so that activity tracking does not depend on network access, while cloud services are limited to authentication and synchronization.

How I Built It

The proposed implementation uses:

Flutter for the cross-platform application
SQLite for local-first activity storage
llama.cpp for local model inference
Qwen3, an open-weight model, for local reflections
A small application/domain layer separating business logic from the UI

The AI pipeline is intentionally narrow:

Activity Data
      +
Optional Good Deed Notes
      │
      ▼
Context Builder
      │
      ▼
Local Open-Weight Model
      │
      ▼
Reflection Validator
      │
      ▼
Monthly Reflection
      │
      ▼
Step Outside

The model only receives the information required to generate the requested reflection.

Personal activity is not sent to a remote AI API.

The AI would have three modes:

Off
Reports only
Reports + personalized suggestions

The suggestion system is deliberately pattern-based and non-judgmental.

The AI is not a religious authority. It must not provide Islamic rulings, judge someone's faith, assign spiritual value, invent activity, or make unsupported claims about the user.

The underlying product architecture is also designed around offline-first behavior. Creating activities, editing them, viewing history, and viewing the activity graph should all work without an internet connection.

Why Does Open Innovation Matter?

This project deals with unusually personal information.

A person's worship activity and private Good Deed notes are not the kind of data I want to send to a remote AI provider simply because a cloud API is convenient.

Local open-weight inference changes that.

The intended architecture is:

                 DEVICE
┌─────────────────────────────────┐
│                                 │
│  Local Activity Database        │
│            │                    │
│            ▼                    │
│     Context Builder             │
│            │                    │
│            ▼                    │
│     Open-Weight Model           │
│            │                    │
│            ▼                    │
│  Reflection / Suggestion        │
│                                 │
└─────────────────────────────────┘

The user's personal activity can remain on the device.

Privacy

The AI doesn't require personal activity to be uploaded to a hosted AI service.

Offline capability

Once the model is installed, the reflection experience can work without an internet connection.

That is particularly relevant to the Touch Grass theme: the application should still be useful when someone is away from reliable connectivity.

Model freedom

The AI layer is intentionally replaceable.

The application should not be architecturally tied to a single proprietary API. Different open-weight models can be tested, optimized, or replaced without redesigning the entire product.

But the most important reason for using open AI is philosophical.

I don't want an AI assistant that tries to maximize the amount of time I spend talking to it.

I want an AI that can look at my activity, help me reflect, and then tell me:

Put the phone down.

That's what makes local open AI meaningful for this project.

My Agent Session

This prototype does not currently have a DevRelay agent session.

The intended development workflow would use an agent to help build and test the local-first architecture, while keeping the application's personal activity data separate from any remote AI service.

Prize Categories

Open-Source AI / Open-Weight AI

The project is designed specifically around an open-weight local model and local inference rather than a closed hosted AI API.

The idea behind Deen Trace

Deen Trace is built around a simple principle:

Real life comes before the app.

The activity graph isn't a spiritual score.

The AI isn't a religious authority.

The app doesn't need to know whether you actually followed its suggestion.

It just needs to help you reflect—and then get out of your way.

Log → Reflect → Leave the screen.

Dead Stock Dost

Aiman Fazal — Sun, 04 Oct 2026 15:18:05 +0000

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

What I Built

I built Dead Stock Dost, a tiny local-first AI tool for a small neighborhood garment shop.

A small shop can have shirts, kurtas, jackets, and other products sitting on shelves for weeks or months. Even with an inventory CSV, it isn't always easy to quickly answer:

Which products need attention?
Why might they be stuck?
What could I try?

Dead Stock Dost takes a simple inventory CSV and turns it into:

CSV → Identify Dead Stock → Explain → Suggest an Action

The application deterministically identifies products that have been sitting unsold for too long, then lets the shopkeeper ask a local AI assistant for an explanation and possible actions.

The AI doesn't make the decision for them.

The code calculates the facts. The AI explains the facts. The shopkeeper decides.

Demo

🎥 Video Demo: https://youtu.be/U6-7b7IAlMg

The complete demo takes less than two minutes:

Open the app
   ↓
Try demo data / Upload CSV
   ↓
See products needing attention
   ↓
Select a product
   ↓
"Why is this stuck?"
   ↓
"What can I try?"
   ↓
Get a local AI response

Code

🔗 GitHub Repository: https://github.com/aimanfazal/dead-stock-dost

The repository contains the application, demo CSV, screenshots, architecture documentation, and project scope.

How I Built It

Dead Stock Dost is built with:

Next.js
React
TypeScript
CSV
LM Studio
Qwen 2.5 3B Instruct

The AI runs locally through LM Studio using an open-weight model.

The application itself handles the inventory logic deterministically:

90+ days: Dead Stock
45–89 days: At Risk
Less than 45 days: Normal
Stock ≤ 0: Ignored

The AI receives the calculated facts for a selected product and helps explain the situation or suggest possible actions.

It does not classify products, modify inventory, change prices, invent facts, or make decisions automatically.

I intentionally kept the architecture small: no database, authentication, cloud AI API, vector database, or multi-agent framework.

The CSV remains the source of truth.

Why Does Open Innovation Matter?

Open innovation made it possible to build this as a local-first AI tool instead of depending on a paid cloud AI API.

Using an open-weight model through local inference means the shopkeeper's inventory data can stay on their own machine while still getting a natural-language AI assistant.

It also makes the project easier to experiment with and adapt without tying the core application to a single hosted AI provider.

For this project, the important part isn't making AI autonomous. It's making a small, useful AI assistant available while keeping the shopkeeper in control.

DEV Community: Aiman Fazal

Deen Trace

What I Built

Deen Trace — an AI that knows when to get out of your way.

Demo

Code

How I Built It

Why Does Open Innovation Matter?

Privacy

Offline capability

Model freedom

My Agent Session

Prize Categories

The idea behind Deen Trace

Dead Stock Dost

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?