DEV Community: amier_san09

AI-Alchemist: Turn Open Models Into Intelligent Creations

amier_san09 — Tue, 27 Oct 2026 22:36:39 +0000

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

What I Built

AI Alchemist is a local laboratory for open-weight models. The tagline is "Turn Open Models Into Intelligent Creations." Version 0.2.0. The command is ai-alchemist. The Python package is ai_alchemist.

I built it because trying a local model usually means a terminal, a host URL, and a guess about whether the reply came from the model I thought I selected. I wanted one page where the model name, the provider, and the reply stay visible, and where two models can answer the same prompt without one of them being declared the winner.

The model runs through Ollama. The browser does not call Ollama itself. A small server on the machine does. The default host is http://127.0.0.1:11434. If that address is loopback (127.0.0.1, localhost, or ::1), the interface says the inference is local. If I point the host anywhere else, the interface says the inference is remote and that the prompt leaves the machine. I did not want a badge that says "local" when the request is actually going somewhere else.

The laboratory has five pages.

Playground is the conversation. I choose a model name, write a prompt, and the reply streams in as tokens. Enter sends. Shift+Enter inserts a line break. Stop aborts the browser read. A stopped partial reply stays on screen so I can see where it cut off, but it is not saved. New conversation clears the screen and does not delete anything already stored. Copy copies a finished reply. A follow-up prompt includes the earlier user and assistant text from that screen. Messages that failed are left out. This release does not add a hidden system prompt. What I see is what is sent.

Compare sends one prompt to two model names. Each side succeeds or fails on its own. If one tag is missing, that column shows the error and the other column can still show a reply. The page does not score them and does not say which one is better. A difference is not a ranking.

Models lists the tags Ollama returns from GET /api/tags. When Ollama includes family, parameter size, quantization, byte size, or a modified time, those fields are shown and labeled as reported by Ollama. I do not add benchmark scores, and I do not invent a download status. If the host cannot be reached, the model count stays unknown. The page does not pretend that zero models are installed when the check itself failed.

History is optional. Saving is off until I turn on "Save experiments on this computer." A finished playground or compare turn is then written to a SQLite file on this computer. Each row is the prompt, the reply, the model, the provider, the kind of turn, and the time. I can delete one row or all of them. Nothing in that file is uploaded.

Settings holds the Ollama host, an optional bearer token, the default model, the comparison model, and the maximum number of output tokens. Test connection checks the form without saving it. A blank token field keeps a token that is already saved. "Clear the saved token" removes it. After a successful save the token is not shown again.

Ghost mode sits at the bottom of the sidebar. It is a darker laboratory theme: obsidian background, emerald accents, gold lines. The choice stays in this browser only. It does not change the model, the host, or the settings file.

What the program refuses to do is part of the design. It does not download model weights. It does not run ollama pull. It does not execute a prompt as a shell command. It does not give the model a tool channel. It does not follow an HTTP redirect from the Ollama host. It does not replace a connection error, a missing model, or an empty body with a paragraph I wrote in advance.

Demo

Linux:

python3 -m venv .venv
source .venv/bin/activate
python -m pip install -e .
ollama serve
ollama pull qwen2.5-coder:1.5b
ai-alchemist

Windows PowerShell:

py -3.11 -m venv .venv
.venv\Scripts\Activate.ps1
python -m pip install -e .
ollama serve
ollama pull qwen2.5-coder:1.5b
ai-alchemist

ollama pull is something I run myself, after I have read the license on that tag. AI Alchemist will not run it. qwen2.5-coder:1.5b is only an example of a small tag. Any tag Ollama can serve is a valid model name, as long as it is a single token.

Then I open http://127.0.0.1:8000. The server binds to loopback. python -m ai_alchemist starts the same process. ai-alchemist --version prints 0.2.0 and does not start the server.

In Settings I leave the host at http://127.0.0.1:11434 unless Ollama is somewhere else. I put the tag I pulled in Default model, choose Test connection, then Save. The sidebar chip should read that Ollama is local and should show how many models the host reported. If Ollama is not running, the chip reads Ollama · Unavailable and a prompt returns that error. The page still opens.

These photographs were taken in the browser while the laboratory was running at 127.0.0.1:8000 and connected to an Ollama-compatible host.

The first photograph is the playground after a reply. The sidebar shows the name, the tagline "Turn Open Models Into Intelligent Creations," and the pages. The header shows the active model and that inference is local. The user prompt is on the right. The model reply is on the left, with Copy. The prompt box, Send, Stop, New conversation, and the save checkbox are at the bottom. Ghost mode is the green control in the sidebar. The chip says Ollama is local and that two models were reported.

The second photograph is the model page. Both cards came from the host's tag list. Each card says "Local host" and "Listed by Ollama," and the description line starts with "Reported by Ollama," including family, parameter size, and quantization. One card is marked Default and the other Comparison. There is no score and no rank.

A second model, if I want Compare, is another tag I have already pulled. I type both names and send one prompt. The two columns fill independently. I do not get a winner.

Code

The source is github.com/gabutersproject/ai-alchemist. The application is MIT. Ollama, the model weights, and the Python dependencies keep their own licenses.

The layout is one process, not a set of services.

Path	What it does
`src/ai_alchemist/web/`	Playground, Compare, Models, History, Settings, and Ghost mode
`src/ai_alchemist/routes.py`	The JSON API and the token stream
`src/ai_alchemist/providers/ollama.py`	`GET /api/tags` and `POST /api/chat`
`src/ai_alchemist/providers/registry.py`	The single place a provider is constructed
`src/ai_alchemist/config.py`	Host, token, model names, and the history switch
`src/ai_alchemist/history.py`	SQLite rows
`src/ai_alchemist/cli.py`	The `ai-alchemist` process

The routes the page uses:

Route	Role
`GET /api/health`	Process health only. It does not claim a model is running.
`GET /api/provider`	Whether the saved host answered, and whether that host is local or remote
`GET /api/models`	Tags from that host
`GET` and `PUT /api/settings`	Public settings. The token value is never included.
`POST /api/settings/test`	Probe the form without saving it
`POST /api/chat/stream`	Playground tokens as server-sent events
`POST /api/compare`	One prompt, two model names
`GET /api/history`	Stored rows
`DELETE /api/history/{id}` and `DELETE /api/history`	Delete one row, or every row

Settings live in lab-config.json under the platform data directory: $XDG_DATA_HOME/ai-alchemist/ or ~/.local/share/ai-alchemist/ on Linux, and %LOCALAPPDATA%\ai-alchemist\ on Windows. AI_ALCHEMIST_DATA_DIR and AI_ALCHEMIST_CONFIG override those paths. The file mode is owner read/write when the operating system allows it.

How I Built It

I split the work so the page does not know the HTTP shape of Ollama. The browser is static HTML, CSS, and JavaScript. FastAPI serves that page and the API. The Ollama client lives in one adapter. Routes ask that adapter to list models or stream a chat. Adding another provider later means a new class behind the same three operations: probe, list, and stream. This release only registers Ollama.

A playground send is POST /api/chat with "stream": true. The body is the model name, the messages on screen, and Ollama's num_predict, taken from max_output_tokens (default 512, allowed range 16 to 4096). There is no tools field. The server reads the newline-delimited JSON from Ollama and forwards each text fragment to the browser as a server-sent event. Stop aborts that read. Closing the stream does not invent the rest of the sentence.

Compare does not stream. It runs both generations with asyncio.gather and returns both results, including a failure on only one side. I did that so a missing tag on the right does not hide a real reply on the left, and so the response has no winner field and no score.

The model list is a parse of /api/tags, not a catalog I maintain. A tag is "available" only because its name was in that JSON. The description string is built from details.family, details.parameter_size, and details.quantization_level when those keys exist. If they do not, the card says Ollama listed the model and did not include a description. The size line is the size integer converted to megabytes or gigabytes and labeled "reported by Ollama."

Failure is explicit. A connection error, a timeout, a redirect, an HTTP error, a tool-call payload, or an empty answer becomes an error message that ends with "AI Alchemist did not invent a replacement answer." A 404 names the missing tag and prints the ollama pull line for me to run myself. A redirect is not followed, so a configured host cannot bounce the prompt to another URL without the request failing. If a provider error echoes the saved bearer token, that string is replaced with [redacted] before it reaches the page.

The token itself never goes back to the browser. GET /api/settings returns token_configured: true or false. The value stays in lab-config.json and is sent only as Authorization: Bearer to the configured host. A host URL that embeds a username or password is rejected. The token belongs in the token field. A turn whose prompt or reply contains that token is not written to SQLite.

History is two gates, not one. The setting persist_experiments must be on, and the request must ask to save. The checkbox in the playground and the checkbox in Settings write the same flag. New conversation and Stop do not delete rows. Delete does.

Ghost mode is a class on the document element, remembered in localStorage under ai-alchemist-ghost. The palette is obsidian #0B0D10, emerald #10B981, gold #D4AF37, and soft white #F5F7FA. Motion is a slow drift on the mark, and it is disabled when the browser asks for reduced motion. The text stays light on the dark background.

Tests do not start Ollama. They use a fake provider for the API and httpx.MockTransport for the adapter: a successful stream, a dead host, a missing model, a tool call, a redirect that must be requested only once, a token that must not reappear in an error, and history that must not be written until saving is enabled. python -m pytest and python -m ruff check src tests are the checks. A green test run is not a live generation. The live check is still Ollama, a tag I pulled, and a prompt in the playground.

An earlier revision of this repository was a read-only terminal inspector for Git trees. That program is not what this post describes. It is not in the current tree. Git history still has it. The laboratory does not read that old config.json.

Why Does Open Innovation Matter?

The laboratory is only useful if I can change the model. Ollama is how that change stays practical. I pull a tag whose license I have actually read, I type that name, and the same page talks to it. I am not required to send the prompt to one hosted API, and I am not required to rewrite the interface when I switch from a 1.5B tag to another tag on the same server.

Local inference is a real boundary only when the host address is loopback. That is why the chip and the model cards say "Local" or "Remote" from the host, not from a marketing string. A remote Ollama-compatible server is allowed. It is labeled remote, and the prompt is sent there. Open infrastructure includes that choice. It does not include hiding it.

Open weights are not one license. Apache-2.0 and a research license are different deals, and an Ollama package can add its own terms. Downloadable weights are not automatically open source. The MIT license on this repository does not relicense Ollama or the weights. I read the model card for the tag I pull. The software can stay replaceable even when the weight license is narrow. Saying that out loud is part of using open models honestly.

A local process also does not make a hostile model safe. It removes one mandatory data path. The prompt still goes to whatever host I configured, and the reply is still the model's reply. The page keeps those two facts separate: the chip tells me where the request went, and the answer is labeled as that model's text.

The Spirit of It

Week 4 asked for a ghost in the machine. I did not want a jump scare, and I did not want a horror skin on a chat box that still calls a vendor when the local service is gone.

The ghost is the model that is actually resident on the computer. Ghost mode is the room it answers from: a dark laboratory, a gold mark, a little motion, and text I can still read. The silence matters as much as the theme. If Ollama is unreachable, the chip says unavailable and the prompt returns the connection error. There is no second voice that fills the pause and pretends the machine spoke.

That is the whole of the spirit I was willing to build. A model can be present. When it is not present, the page should admit it.

Prize: Best Use of Ollama

I am submitting AI Alchemist for the best use of Ollama. This section is the category I am writing for. It is not a claim that the prize has been awarded.

Ollama is the inference engine, not a sentence in the introduction. Every reply the playground shows comes from POST /api/chat on the configured host. Every card on the model page comes from GET /api/tags. Compare is two of those chat calls, so two tags I have already installed can answer one prompt. The default host is Ollama's own loopback port. A missing tag produces the ollama pull command and does not download the weights. A host that is not loopback is called remote. A host that does not answer is called unavailable, and the page does not invent the rest.

That is the use I wanted from Ollama: run an open-weight model on the machine, see the tag I actually selected, and keep a second tag beside it when I want to look at both answers. The laboratory is the room around that use. Ollama is the machine inside the room.

Happy Hacking!

Slow and Steady: local, open-source AI that helps you work without urgency or cloud lock-in

amier_san09 — Tue, 20 Oct 2026 21:04:22 +0000

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

What I Built

Slow and Steady is a personal AI workspace that runs on the machine in front of you.

The idea is sloth-shaped on purpose. Most “AI assistants” ask you to open an account, paste private text into someone else’s API, and keep paying per token. That is a lot of fuss for a tool that is supposed to take work off your plate. This app does the opposite: install it once, talk to an open-source model on localhost, and keep the conversation in a SQLite file on disk.

It helps with the work people put off: explain a hard topic, tidy a paragraph, sketch a project, walk through a code snippet, or just sit with a calm chat window. The computer does the drafting. You stay in the chair.

There is a Demo Mode so you can use the whole interface before you download a model. Demo replies are scripted and labelled as scripted. They never pretend to be a language model, and they never silently replace a failed local request.

When you are ready, connect Ollama, pick an installed model such as qwen2.5:1.5b, and chat for real. Streaming, stop, regenerate, Markdown, code highlighting, and conversation history all work the same way in both modes.

What it does

Chat with streaming, stop, regenerate, copy, and Markdown
Keep history locally: create, rename, delete, continue, clear all
Choose Demo Mode or any model already installed in Ollama
Tune temperature, max tokens, system prompt, and streaming
Show an honest status: Demo Mode, Local AI Ready, Model Loading, Generating, Model Not Found, Ollama Offline, Backend Unavailable

Local AI Ready is only shown after the backend has checked that Ollama answers and the selected model is installed.

Demo

Code

GitHub: https://github.com/gabutersproject/slow-and-steady
Run locally: see the README — open http://127.0.0.1:4747 after starting both processes

Quick path for judges who do not want to pull a model:

./scripts/start-backend.sh    # terminal 1
./scripts/start-frontend.sh   # terminal 2

Click Start Demo. Suggested prompts are on the empty chat. Replies are labelled scripted, not an AI model.

To use a real open-weight model (not automatic — you pull it):

ollama pull qwen2.5:1.5b

Then choose that model in the sidebar.

How I Built It

Two processes, both on loopback.

Browser (Vite + React)  →  FastAPI on 127.0.0.1:8747  →  Ollama on 127.0.0.1:11434
                                ↓
                         SQLite (chats + settings)

The UI never talks to a model. An abstract AIProvider sits behind the API with two implementations:

DemoProvider — a small set of scripted replies, streamed in chunks so the UI path is the same as a real model.
OllamaProvider — local HTTP only (/api/tags, /api/chat). No cloud fallback. No auto-download.

Stack:

Layer	Choice
Frontend	React 19, TypeScript, Vite 8, Tailwind CSS 4, Lucide
Backend	Python, FastAPI, Pydantic v2
Inference	Ollama + open-weight models (example: Qwen2.5 1.5B)
Data	SQLite via aiosqlite
Tests	Pytest (Ollama mocked) and Vitest

Security choices that match the theme of “do less, leak less”:

Bind the API to localhost; CORS only for the local Vite origin
Validate temperature, token limits, message length, and model names
One generation per conversation at a time (no interleaved history)
Stop/cancel persists partial text as cancelled, never as a finished answer
No shell from model output, no secret leakage in error payloads, no arbitrary file tools in chat

Tests run without a downloaded model. Last run in the build environment: 46 backend tests passed, 17 frontend tests passed. Live generation against a real Ollama instance was not verified in that environment because Ollama was not installed there; offline detection and the mocked provider suite were.

Why Does Open Innovation Matter?

The closed path for a chat app is easy: drop in a paid API key and ship. It is also the path that sends every draft, code snippet, and half-formed question to a server you do not run.

Slow and Steady is built so the open pieces are the product, not a badge:

Your words stay here. History is a local SQLite file. The model, when connected, is a process on 127.0.0.1.
No meter running. After npm install, pip install, and an optional ollama pull, chat does not call a cloud LLM. You are not renting intelligence by the token.
You can swap the brain. Any model Ollama lists is selectable. The UI does not care whether it is Qwen, Llama, or something else you pulled yourself.
It still works when you are tired. Demo Mode is the sloth door: explore the app at 11pm without waiting on a multi-gigabyte download. Connect a real model when you have the energy.

A closed API would have been faster to stub and worse at the job. The job is a private, unhurried assistant that does the typing so you do not have to.

Prize Categories

Hacktoberfest Open-Source AI Challenge: Week 3 (theme: Slow and Steady) — overall

No partner runtime is required for this project. It is meant to live on a laptop, not on a hosted GPU. I am not claiming Render, Gemma-as-a-service, DigitalOcean, or other partner categories unless those are added later with a real integration.

Sawhorse: a quoting desk that isn't allowed to invent a price

amier_san09 — Mon, 12 Oct 2026 23:22:29 +0000

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

What I Built

Sawhorse is a quoting desk for a one-person custom furniture shop.

A maker gets a text like this: "We just bought a place in Catskill. Table for six, maybe eight with a leaf. Walnut if it's not crazy, otherwise white oak. My partner hates glossy finishes. Before Thanksgiving if that's even possible. Budget is around 4–5k. We're about 40 minutes from Hudson."

The tedious part is not writing a polite reply. It is turning that note into hours, board feet, and an honest no. At this shop's rate card, black walnut is $5,592. White oak is $4,438. Thanksgiving falls inside a 10 to 14 week lead time, so the letter says that date is not a promise.

The person who pays is an independent furniture maker, or the same kind of one-person shop in another trade: someone who already has a rate card, quotes from messy client texts, and does not want that text or those rates in a chatbot. A $40/month proposal tool still does not know a trestle base from a pedestal. Pasting the note into a general model produces a retail-shaped number the shop cannot build for.

The sample shop is Mara Ellison Studio in Hudson, New York. Her card is $85 an hour, white oak at $14 a board foot, walnut at $32, and delivery zones for town, the mid-Hudson, and New York City. Two other notes are built in: Jonah's hard-maple desk with a cable hole, which lands at $1,913 against a $2,000 ceiling, and Andre's four-foot bookshelf to Brooklyn, which comes in at $1,837 against "under fifteen hundred."

Demo

The sample desk is here: https://gabuters-sawhorse.surge.sh

Open Priya's note. The weights download into your browser, about 1.1 GB, once, and then the model reads the note on that machine. White oak is the one to send, because walnut is over the range, and the letter says Thanksgiving is inside the lead time. You can change any field before a dollar is calculated. Nothing in the note is uploaded.

A shop install is the same desk with the weights already on the laptop. pnpm dev serves it at http://127.0.0.1:43123. A short note usually reads in under a minute on a 4-core CPU with no GPU. The rate card and the glossary are editable. Saved tickets stay in a JSON file next to the app.

Code

gabutersproject / hustle-ai-kit

Sawhorse

Sawhorse is a quoting desk for a one-person furniture shop. Paste a client note. An open-weight model on this machine reads it into a job ticket. The shop's rate card, not the model, sets every dollar.

The sample shop is Mara Ellison's, in Hudson, New York. Priya writes from Catskill about a dining table, walnut if it fits, otherwise white oak, no gloss, before Thanksgiving, four to five thousand dollars. Sawhorse prices both woods from Mara's hours and board feet, recommends the one that lands in the budget, and says plainly that Thanksgiving is inside a 10 to 14 week lead time.

Why the open model is the product

Qwen2.5-1.5B-Instruct (Q5_K_M, Apache-2.0) runs in llama.cpp through llama-cpp-python. No API key. The reply is constrained to a JSON schema that has no price field, and the prompt does not include the hourly rate or the lumber prices. A general…

View on GitHub

The split that matters:

engine/reader.py asks the model for a job ticket. The JSON schema has a client, a piece, woods, a finish, a delivery zone, a budget, and the client's own words for the deadline. It has no price field.
engine/pricer.py is ordinary arithmetic. Lumber is board feet times the species rate. Labor is hours times the shop rate. Delivery is a zone fee. A design drawing is added and, if the shop says so, credited back.
engine/letter.py may print a dollar amount only after that math. A test fails if the letter contains any dollar figure that is not on the ticket.
data/pricebook.default.json is Mara's rate card. Edits and saved quotes stay in data/ on the machine and are not part of the repo.

# engine/reader.py — the grammar the model is held to
properties = {
    "client_name": {"type": "string"},
    "piece": {"type": "string", "enum": pieces},
    "species_primary": {"type": "string", "enum": species + ["unspecified"]},
    "species_alternate": {"type": "string", "enum": species + ["none"]},
    "finish": {"type": "string", "enum": finishes + ["unspecified"]},
    "delivery": {"type": "string", "enum": zones + ["unspecified"]},
    "budget_low": {"type": "integer"},
    "budget_high": {"type": "integer"},
    "deadline_raw": {"type": "string"},
    # no price, no hours, no board feet
}

How I Built It

The open-weight model is Qwen2.5-1.5B-Instruct, quantized Q5_K_M, Apache-2.0, about 1.2 GB. Inference is llama.cpp through llama-cpp-python, on CPU. There is no API key.

create_chat_completion is called with response_format set to a JSON schema. llama.cpp compiles that schema into a grammar, so the reply cannot leave the ticket shape. The prompt lists piece ids, wood ids, finish ids, delivery zones, and the shop glossary. It does not include the hourly rate or the lumber prices. "Catskill" means the mid-Hudson zone. "Hates glossy" means hardwax oil. "Hard maple" means maple. The model cannot anchor on a number it was never shown.

A 1.5 billion parameter model still copies the shape of its examples. After the read, apply_note_guards fixes two high-confidence misses: if the word "leaf" is in the note, the ticket includes a leaf; if the note says the room is "9 feet by 11" and the model copies 9 and 11 into the furniture dimensions, those values are dropped, because that was the room. The maker still sees every field and can change it before pricing.

The desk is a Next.js app. A FastAPI process on localhost holds the weights. The browser talks only to Next, and Next proxies to that process, so a read never leaves the machine. The hosted sample keeps that split, only the process is the browser: llama.cpp runs there, and the rate card is the same Python. The glossary is the niche list a shop will actually edit: towns, finish phrases, species nicknames. The next note uses it. The same weights can take a LoRA later, trained on quotes the shop really sent.

Why Does Open Innovation Matter?

A frontier API would read one of these notes for less than a cent. That is not the bill that breaks a shop quoting fifteen small jobs in a month.

What breaks it is a wrong number, or a leaked one. A general chat model asked to "quote this walnut table" reaches for retail: a round number and a confident email, at a price the shop cannot build for. Sending that loses the job or gives away the margin. The same model does not know that Catskill is about forty minutes from this shop. You can paste a glossary into a hosted prompt. You also paste the client's town, their budget, and sometimes why they need the table by a certain Thursday. In a town this size that note is not anonymous, and the rate card is the business.

The open weight file is what makes the stricter design possible. llama.cpp will bind the reply to a grammar with no price field. The prompt is not given the rates, so there is nothing for the model to repeat. The weights are Apache-2.0, so the desk can be sold without renting the brain. They are small enough that a shop laptop with no GPU can run them. If the app disappeared, the rate card and the saved tickets would still be JSON files, and the model would still be a file beside them. Nobody gets to reprice the inference out from under a $4,000 job.

The glossary is not a fine-tune. It is the adjustment a one-person shop will keep. A closed API does not hand you the weights to train later, and it does not hand you a grammar that forbids a price.

Crashtoberfest? Happy Hacking

Touch Grass Sports AI – Offline AI That Gets You Outside

amier_san09 — Mon, 05 Oct 2026 21:59:06 +0000

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

What I Built

Touch Grass Sports AI is a fully offline open-source AI that generates personalized outdoor sports challenges.

Its only mission: get you off the screen and into the real world.

You pick your fitness level, sport, available time, and location. It replies with a concrete challenge that must be done outside and always includes a real “touch grass” moment.

Supports many sports: running, basketball, cycling, yoga, swimming, climbing, parkour, volleyball, tennis, skateboarding, martial arts, hiking, and more.

Works in two modes:

Local LLM (Ollama) for creative challenges
Pure rule-based mode (no model needed)

Demo

Web-UI

CLI

Code

GitHub: https://github.com/gabutersproject/touch-grass-sports-ai

How I Built It

Built entirely around open-source AI and local inference:

Ollama for running open-weight models locally (Llama 3.2, Phi-3, Gemma 2, etc.)
Strict system prompts that force every output to be outdoor-only + include a touch-grass action
Multi-language support (English + Indonesian)
Gradio web UI + pure CLI
Full rule-based fallback so it works even without any LLM

Why Does Open Innovation Matter?

A closed cloud API would have killed the whole idea.

Runs completely offline (useful on trails and parks with no signal)
Zero data leaves the device
Free forever, no API costs
Fully customizable (swap models, edit prompts, expand challenges)
Aligns with the “touch grass” philosophy — less dopamine, more real life Open-weight models + local inference made this possible.

Thanks for reading!

Go outside. Touch grass. Move your body. 🏃‍♂️🌿

Hacktoberfest26: Beginner build for a Friend

amier_san09 — Fri, 02 Oct 2026 14:56:31 +0000

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

Happy Hacktoberfest, everyone! 🎃

I’m super excited to participate in the Hacktoberfest 2026 DEV Challenges, specifically the Weekend Challenge: Build for a Friend!. Open source is all about community, and what better way to kick things off than building something helpful for someone you know?