DEV Community: Bharani Kumar Reddy Kudala

Ghostlight: a cabinet of haunted objects powered by local, open-weight AI

Bharani Kumar Reddy Kudala — Tue, 27 Oct 2026 20:02:16 +0000

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

What I Built

Ghostlight gives ordinary objects a fictional afterlife. Name an object, choose a setting and a feeling, and a small language model writes a spooky story fragment in your browser. Keep it in a local cabinet or export it as Markdown.

The interpretation of “Ghost in the Machine” is literal: the machine invents the ghost, while a familiar object gives the story somewhere to live. The interface is a midnight-green museum desk with an illuminated bell jar and paper-like story cards. These are invented stories, not historical accounts or simulations of real people.

Demo

Open Ghostlight

For a quick look, try the clearly labeled sample. It does not run the model. For actual generation, enter an object, choose the setting and mood, then awaken its story.

First generation downloads roughly 550 MB of model and runtime files. A capable desktop is recommended. Loading and generation can take a few minutes, and mobile performance has not been verified. No account, API key or paid inference service is required.

Code

GitHub repository

The application code is MIT licensed. The model and dependencies keep their own licenses.

How I Built It

The generation path uses Qwen2.5-0.5B-Instruct, with 8-bit ONNX weights, through Transformers.js and ONNX Runtime Web. Inference runs in a dedicated browser worker on CPU/WebAssembly, so WebGPU is not required.

The rest is a static JavaScript/Vite app deployed on GitHub Pages:

A bounded prompt supplies the object, setting and mood to the model.
The worker handles loading and generation; cancellation terminates it.
Saved stories stay in this browser’s localStorage, with Markdown export for a separate copy.
Model output is rendered as text, not executable HTML.
A sample is kept separate from generated results and never silently substitutes for failed inference.

The small model is a real constraint. It can repeat itself or ignore details. A live desktop test produced a coherent station story but left out the requested brass key. Generation is limited to 220 tokens; a trailing unfinished sentence is dropped rather than completed with fabricated fallback text. That is why the app calls its output a story fragment.

Verification included 21 automated core tests, type checking, a production build, and live desktop checks of real model generation, cancellation, save, reload, export and deletion. These checks do not establish reliability on every browser or phone.

Why Does Open Innovation Matter?

Open weights make the story engine inspectable and replaceable. The prompt, worker and model choice are visible in the repository instead of hidden behind an inference endpoint. Someone can change the tone or try another compatible model without depending on a hosted text-generation API.

Local execution also changes where the story goes. Object names and generated text are not sent to an inference service. Model downloads still contact Hugging Face/CDN hosts, and the page uses Google Fonts, so this is not a claim of zero network contact. Saved stories are not encrypted, and clearing site data removes them.

There is no per-story API bill, but the cost moves to download size, memory and CPU time on the reader’s device. Offline availability is not guaranteed: the app has no service worker, and browser caches can be evicted. Those tradeoffs are part of the project rather than hidden behind the demo.

AI Disclosure

An AI coding assistant developed the project and generated this write-up. The included sample was written during that assisted build, not by the on-device model. This post uses DEV’s Fully Autonomous disclosure.

QuietQueue: batch the little chores with on-device, open-weight AI

Bharani Kumar Reddy Kudala — Tue, 20 Oct 2026 23:57:44 +0000

This is a submission for the Hacktoberfest 2026 Week 3: Slow and Steady challenge.

What I Built

QuietQueue turns a scattered to-do list into a small session of related tasks. Paste one task per line, choose a time budget and an energy setting, and get a plan with the rest safely parked for later.

The goal is simple: spend less effort deciding what to do next and switching between unrelated chores. It does not send messages, book anything, or perform your tasks. It helps organize them.

The optional AI runs in your browser. It uses an open-weight sentence-embedding model to group tasks by meaning, while a deterministic planner enforces the time and energy limits. A clearly labeled rule-based mode works without loading the model.

Demo

Try QuietQueue

Start with Try an example, choose 30 minutes, and select Make a quiet plan. Then enable Group with on-device AI to try semantic grouping. The first AI run downloads model weights and the runtime; allow time for that download. Check off tasks and export your plan as Markdown.

Task text stays on the device. The model hosts receive ordinary download requests, not your task list. Local storage is not encrypted, so avoid sensitive information on a shared device.

Code

Source code on GitHub

This is a new project and repository created on October 20, 2026 for this challenge, rather than an extension of an earlier entry. Original application code is MIT-licensed; dependencies and model weights retain their own licenses.

How I Built It

QuietQueue is a buildless HTML, CSS and JavaScript application. Transformers.js 3.8.1 loads the quantized Xenova/all-MiniLM-L6-v2 model. Both the model conversion and upstream sentence-transformer are open-weight Apache-2.0 projects.

The model produces 384-dimensional embeddings for the tasks and six context descriptions. Cosine similarity matches a task to a context such as messages, errands or home chores. Weak matches stay in a loose-ends group rather than being presented as confident classifications.

A separate bounded planner selects tasks within the chosen time budget. Duration estimates come from user input or simple, labeled heuristics, not the model. The model never invents tasks or deadlines. This keeps fuzzy language matching separate from the hard planning constraints.

Nineteen automated tests cover task conservation, budgets, energy filters, duplicates, malformed embeddings, export provenance and bounded input. A real-model integration test also downloaded and executed MiniLM on synthetic tasks; it was not a mocked AI response. The deployed browser demo was also exercised: actual on-device AI completed successfully, a 15-minute budget produced three five-minute tasks, check-offs persisted after reload, and Markdown export downloaded successfully.

An autonomous AI assistant implemented the application and tests. This entire post was generated by that assistant, with no substantive human editing. The embedded runtime model is distinct from the development assistant. No model training or fine-tuning is claimed.

Why Does Open Innovation Matter?

For this project, open weights make local inference practical without an API key or a per-plan inference bill. A task list does not need to travel to a hosted language-model endpoint just to be grouped.

The model, category descriptions, similarity threshold and planning algorithm are inspectable. Someone can change the contexts, swap the embedding model or run the static app themselves. The repository includes attribution and licensing notes so those choices are visible.

There are limits: the model is English-first, unusual phrases can be misclassified, and this is local-first rather than a guaranteed fully offline app. Initial loading needs a network connection and browser caches can be evicted. If AI cannot load, the interface explicitly says it is using rules instead.

The Lazy Payoff

The intended payoff is less planning friction: a short session, related chores together, and permission to leave the rest for later. QuietQueue shows changes in context-switch count for the same selected tasks, not invented minutes saved or a measured productivity claim.

No paid API, account or backend database is required. The demo is a small experiment in using open AI to make everyday work feel more manageable.

ScopeCheck: reviewing “one small change” with local open-weight AI

Bharani Kumar Reddy Kudala — Thu, 15 Oct 2026 16:19:38 +0000

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

What I Built

“Could you add one more thing?” is a simple request with an awkward follow-up: was that thing part of the agreement?

ScopeCheck is a browser-local scope review desk for freelance developers and designers. It puts incoming client requests beside the original agreed scope, uses an open-weight model to compare their wording, and helps the freelancer prepare a clear change conversation.

The workflow is deliberately small:

Enter the agreed scope and incoming requests, one item per line
Run a local AI review and inspect the original scope evidence
Keep or override each suggestion, add your own hours and notes, and export a change brief

The app can suggest “Likely covered,” “Possible change,” or “Needs clarification.” A human decides what those suggestions mean for the project. ScopeCheck does not send client messages, invent billable hours, or decide contractual obligations.

The intended customer is an independent professional who needs a repeatable way to review small changes before doing the work. The commercial hypothesis is a $29 one-time, local-first tool, with no metered inference bill. That price is unvalidated. There are no claimed customers, sales, or measured time savings, and the challenge demo has no payment flow.

Demo

Try ScopeCheck

The opening project is explicitly fictional. It is there so you can explore the workflow without entering any client information.

To try it, start the local review and approve the model download. The first run needs an internet connection and roughly 120 MB of model, tokenizer, and runtime assets. Inspect the evidence for a request, change its decision if needed, and enter your own estimate. The Change brief view then produces a plain-text summary and an editable client-response template.

Desktop Chromium is the initial target. Mobile performance and Safari/Firefox support remain unverified. This is a working prototype with real model inference, not a promise of production reliability.

Code

ScopeCheck source on GitHub

The application source is Apache-2.0. The repository includes readable JavaScript modules, regression tests, model smoke-test results, and third-party notices. It is a new project created during the Week 2 entry window.

You can also serve the static dist directory locally. No build step, API key, backend, or app account is needed.

How I Built It

ScopeCheck uses cross-encoder/nli-deberta-v3-xsmall, an Apache-2.0 natural-language-inference model, through Xenova’s quantized ONNX conversion. Transformers.js runs single-threaded WASM inference in a dedicated browser worker.

For each request that passes the ambiguity and length checks, the model compares the original request against every agreed scope item. It returns three scores: entailment, contradiction, and neutral. Those scores help select relevant evidence and support cautious suggestions. The app shows exact source excerpts rather than generating an explanation that could invent an agreement.

Several choices came from the model’s mistakes:

Neutral output stays uncertain. Missing support is not proof that work is extra
Quantity discrepancies and ambiguous wording get separate, deterministic checks
Pairs longer than 512 tokens are rejected instead of being silently truncated
Conditions and exclusions stay in the original text
Every suggestion can be overridden by the person responsible for the client relationship

A confident answer can still be wrong

In an exploratory test, a conditional promise to integrate Stripe produced about 99% entailment for an unconditional integration request. The score did not establish whether the condition had been met.

“One more revision” exposed a different problem: the model could strongly predict contradiction without knowing how many revision rounds had already happened. That missing project history matters more than a confident score.

These are general-English NLI scores, not probabilities of legal coverage. ScopeCheck retains them as inspectable evidence and keeps final decisions with the user.

What was tested

All 62 tests passed again on October 15, 2026, using Node 24.19.0 with jsdom 26.1.0: 31 core, 20 simulated UI, 10 mocked-worker tests, and one stylesheet regression. JavaScript syntax checks passed. These are not browser end-to-end tests.

The deployed GitHub Pages app was also checked in desktop Chromium on October 15. The model-download confirmation led to a completed local review: three sample requests were compared by the model, while the vague fourth request was held for clarification. The email-contact-form request showed 99.4% textual support.

The live-browser check also covered a human override, a two-hour estimate at the fictional sample rate of $85/hour, notes in the generated brief, clipboard copy verified by pasting, and the downloaded plain-text file. The $170 estimate and incomplete-estimate warning survived export, and an edited response survived navigation between views. These are smoke checks, not a full accessibility or cross-browser audit. Mobile, Safari/Firefox, offline behavior, and long-session reliability remain unverified.

Separately, the real quantized model ran on 27 handwritten premise/request pairs using both native ONNX CPU and single-thread WASM in Node. The highest-scoring labels matched across all 27 pairs. That checks runtime consistency on a small exploratory set; it does not establish accuracy on freelance agreements. The repository preserves the scores and failure cases.

Why Does Open Innovation Matter?

Local inference changes the economics and the data boundary of this particular tool.

Client scope text does not need to be sent to an inference service. Project text stays in the tab’s memory, and the application includes no analytics or document upload. Closing or refreshing the tab loses that project text. Users explicitly copy or download the brief when they want to keep it.

There are still network requests for the app, inference runtime, and model files. Those providers receive ordinary request metadata, such as an IP address. Model files may remain in the browser’s cache, and offline operation is not guaranteed. “Local” should describe where the text is processed, without hiding those boundaries.

The open-weight approach also removes per-review API charges. It makes a one-time-purchase hypothesis worth testing, although customer demand and support costs are still unknown. The trade-off is a substantial first download and dependence on the visitor’s browser and available memory.

Finally, the model, conversion, runtime, and application logic are inspectable. Another developer can reproduce the failure cases, change the thresholds, or evaluate a different model. That is useful for a tool whose most important behavior may be admitting uncertainty.

Build Disclosure

An OpenAI coding assistant produced the implementation, testing, and this write-up autonomously. I authorized the project and uploaded the source for publication. This post is labeled Fully Autonomous. The AI used inside ScopeCheck is the open-weight NLI model described above. No customer interviews or firsthand customer outcomes are claimed.

The next validation step is to observe freelancers reviewing their own examples, measure whether the brief improves the conversation, and learn whether they would pay for it. The prototype establishes the workflow; it does not establish a business yet.

Outward: three outdoor missions matched by an open model

Bharani Kumar Reddy Kudala — Tue, 06 Oct 2026 22:39:59 +0000

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

What I Built

Outward gives you three small things to do outside, matched to a short description of what you feel like doing. Choose a neighborhood, park, or doorstep; ten, twenty, or thirty minutes; and whether to wander or stay in one spot. Read the suggestions, start pocket mode, and put the phone away.

The project is for the gap between wanting a break and deciding what to do. A mission might ask you to watch one thing change or notice a small pattern. A familiar place is enough. There is no route to follow, account to create, or location permission to grant.

An open sentence-embedding model matches your words to a fixed, inspectable catalog of 22 missions. It selects existing instructions. Setting and movement preferences are hard constraints, and Skip listening activities removes the catalog's listening category. You can ask for another set without repeating the three currently shown.

Pocket mode keeps those three titles visible and offers the full instructions when needed. Afterward, an optional field note gives you somewhere to keep one observation. The design aims to make the screen a short part of an outdoor break. No outdoor trial or measured benefit is claimed in this write-up.

Demo

Try Outward

Try a sample input such as “I want to listen to birds and natural sounds,” choose Park or green space, 20 min, and A gentle wander, then select Find my field trip. The first AI run downloads model and runtime assets. A completed AI plan is labeled MATCHED ON YOUR DEVICE.

Read the missions, choose Take this outside, and return with I'm back to save a field note. Use a safe, familiar place and skip any task that does not fit your surroundings or ability.

There is also an explicitly selected sample mode, labeled SAMPLE · NO AI USED. A model failure never silently switches to that mode.

Code

Public repository: kudala-bharani/Outward

Outward began on October 5, 2026. The application uses React, TypeScript, and Vite. Original application code is MIT-licensed; third-party components retain their own licenses and notices.

Start with src/data/missions.ts for the catalog, src/ai/model.ts for local inference, src/ai/rank.ts for selection, and src/storage.ts for persistence. The repository includes setup instructions, tests, architecture notes, and machine-readable model evidence.

How I Built It

The model is Xenova/all-MiniLM-L6-v2, an ONNX distribution of the Sentence Transformers model, running through Transformers.js. Both the model distribution and runtime use Apache-2.0. Transformers.js is pinned to 4.3.0, and the q8 model is pinned to revision 751bff37182d3f1213fa05d7196b954e230abad9.

A dedicated browser worker embeds the input and mission descriptions into 384-dimensional vectors. Cosine similarity measures relevance; a small penalty for redundant missions adds variety. The selector applies explicit setting, movement, and listening constraints before choosing three missions. Duration sets the outing timer; it does not estimate the time needed for each activity.

Two recorded examples show how the matching responds:

In the real Chromium browser walkthrough, “I want to listen to birds and natural sounds.” selected Wait for a wingbeat, Make a sound map, and Watch the invisible
In the Node-hosted WASM test, “I am exhausted and want to sit quietly without having to do anything.” selected Let the view be enough, Watch one thing change, and Find the quieter edge

These are actual model outputs. The English-focused model can still misread context; relevance does not establish safety or benefit.

October 6 verification passed TypeScript, 179 automated tests, the production build, native CPU inference, and browser-target WASM inference inside Node. npm run test:model-filters reproduced 36 constraint plans.

A separate manual Chromium walkthrough passed real AI matching, cancellation/retry, non-repeating second sets, stale-plan protection, and doorstep/stationary/listening constraints. Pocket mode survived reload with its countdown catching up. A fictional journal note passed export, duplicate-safe restore, deletion, and Undo. Desktop and narrow layouts were checked, along with keyboard opening/closing of an explanation dialog. The full Playwright suite, offline reload, and a physical mobile device remain untested. Evidence and scope are recorded in the repository's docs/verification.md.

A development correction concerned storage: the initial active-trip record retained the original input. The current version saves missions and timing while removing the mood text, matching query, model name, and similarity scores. Field notes are never sent to the model. Validated JSON export and restore provide a manual backup; deletion is confirmed and can be undone while the page stays open.

AI agents materially implemented the application, tests, and documentation under my direction. This article was primarily generated by AI agents from the source and recorded evidence. Development assistance is separate from the open model that performs matching inside the app.

Why Does Open Innovation Matter?

A downloadable model makes the inference boundary a concrete implementation choice. Outward can compare the input with the catalog locally without sending that text to a hosted inference API or operating an inference server. The model, tokenizer, pinned revision, and selection logic can be inspected and tested together.

Contributors can improve mission wording, change constraints, compare embedding models, or add language coverage with appropriate evaluation. The catalog and ranking behavior are small enough to examine directly.

There are costs to this approach. The first run needs a network connection and downloads roughly 23 MB of weights plus the runtime and supporting files. Asset providers receive ordinary request metadata. Browser storage and exported notes are unencrypted, and cached assets do not guarantee offline availability.

Open components make this small, account-free design practical and reproducible. They also make its limits visible: the source shows exactly what is selected, what is stored, and what still needs testing.