DEV Community: Tushar Vaghela

Hacktoberfest 2026: I Built a Time Machine for My Kids (and Three Other Projects!) 🚀

Tushar Vaghela — Sat, 31 Oct 2026 14:18:14 +0000

This is a submission for the MLH x DEV Writing Challenge.

What I Built

I started programming with BASIC in the 1990s.

Back then, there was no Stack Overflow, no GitHub Copilot, and definitely no AI writing code for you. Just a blinking cursor, a lot of curiosity, and the excitement of making something work.

More than 30 years later, I still get excited about building things.

For Hacktoberfest 2026, I decided to experiment with Cursor and OpenAI Codex and ended up building four completely different open-source projects.

One takes you back to 1988. One helps you find a job. One brings BASIC back to life. And one lets you experiment with AI on your own machine.

Here's what happened.

📺 1. 1988.in — A Time Machine for My Kids

Remember when watching TV meant actually watching whatever was on?

No Netflix. No binge-watching. No recommendations asking, "Because you watched this..."

You switched on the TV, changed channels, and enjoyed whatever was playing.

I wanted my kids to experience a little bit of my childhood.

So I built 1988.in, a retro television experience that brings back the simplicity of watching TV in the late 1980s.

What makes it different?

📺 A classic retro television interface.
📡 Channel surfing instead of scrolling through endless recommendations.
⏪ No skipping, seeking, or choosing what plays next.
📱 Your phone can work as a TV remote.
🕰️ A little time travel, right from your browser.

My kids loved their trip to 1988!

That alone made the project worth building.

But then something unexpected happened.

When I launched it on Peerlist, I received 9 upvotes.

Not 900. Not 90. Just 9. 😄

I thought that would be the end of the story.

But today, 1988.in has 1,500+ active users!

And here's the funny part: I still have no idea how most of them discovered it.

Maybe nostalgia has its own recommendation algorithm!

It reminded me that sometimes the number of people using what you build matters far more than the number of people applauding its launch.

🔗 Travel to 1988 | GitHub

💼 2. Job Ready — Your Resume Doesn't Need Fiction

We've all seen AI tools promising to make resumes "10x better."

But what does that mean? Adding skills you've never used? Turning a small contribution into "led an enterprise-wide transformation"?

I wanted something different.

Job Ready helps candidates understand how well their actual experience matches a job description.

It helps you:

Upload your resume and compare it with a job description.
Identify matching skills and missing requirements.
Understand where you're a strong fit.
Improve how your real experience is presented.
Discover what to learn to become a better candidate.

The philosophy behind the project is simple:

Use AI to explain your experience better, not invent a career you never had.

🔗 Try Job Ready | GitHub

👻 3. Ghost BASIC — Hello, Old Friend!

My programming journey started with BASIC.

If you remember writing something like this, we probably belong to the same generation:

10 PRINT "HELLO, WORLD!"
20 GOTO 10

And yes, we've all written an infinite loop at least once. 😄

For Hacktoberfest, I wanted to bring back that experience.

So I built Ghost BASIC, a Python-based terminal application inspired by the good old GW-BASIC and QBASIC.

It includes:

Classic line-numbered BASIC programming.
Loops, conditions, arrays, and subroutines.
A terminal-based programming environment.
Built-in examples and documentation.
Optional AI assistance using Ollama for debugging and explaining code.

The idea is to combine the simplicity of old-school programming with modern developer tools.

Thirty years later, BASIC still makes me smile.

🔗 Explore Ghost BASIC | GitHub

🤖 4. Local LLM Studio — Your AI, Your Machine

Everyone is talking about AI. But why should every experiment require a cloud API?

With Ollama, LM Studio, and llama.cpp, we can run language models locally.

The challenge is making the experience simple enough for anyone to explore.

That's why I built Local LLM Studio.

It lets you:

Chat with models running on your computer.
Connect to Ollama, LM Studio, and compatible local model servers.
Discover available models.
Compare model response speeds.
Keep conversations stored locally.

It's designed to make local AI experimentation easier, without requiring developers to build their own interface from scratch.

Sometimes the most interesting AI experiments happen without sending everything to the cloud.

🔗 Explore Local LLM Studio | GitHub

Demo

Four projects, four different experiments, and plenty of lessons learned.

Project	Demo / Showcase	Source Code
📺 1988.in	Time Travel	GitHub
💼 Job Ready	Try It	GitHub
👻 Ghost BASIC	Explore	GitHub
🤖 Local LLM Studio	Explore	GitHub

All four projects are open source. Feel free to explore, raise issues, or contribute.

Partner Technologies

One of the fun parts of Hacktoberfest was experimenting with different tools and services to turn weekend ideas into working projects.

💰 $50 Hosting Render Credits — From Localhost to Live

I used $50 in hosting Render credits to deploy Job Ready.

Instead of keeping the project running only on my laptop, I could make it publicly accessible at jobready.tech.

For an experimental open-source project, credits like these are especially useful. They let you focus on building and testing ideas rather than immediately worrying about infrastructure expenses.

🌐 Get.Tech — A Free Domain for Job Ready

Thanks to Get.Tech, I got a free .tech domain for Job Ready.

There's something satisfying about seeing your project running on its own domain instead of localhost.

From an idea to jobready.tech!

🦙 Ollama — AI Across Three Projects

Ollama became part of three of my Hacktoberfest experiments.

Job Ready: Integrating AI capabilities for resume analysis and improvement.
Ghost BASIC: Adding optional AI-powered debugging and code explanations.
Local LLM Studio: Connecting to locally hosted language models and experimenting with different inference setups.

What I enjoyed most about Ollama was the ability to experiment with AI without making every feature dependent on a paid cloud API.

It also opened up interesting possibilities around privacy, local development, and developer-controlled AI infrastructure.

💻 Cursor + OpenAI Codex — My AI Coding Companions

I used Cursor and OpenAI Codex throughout these four projects.

The experience was fascinating.

An idea that previously required considerable setup and boilerplate could now become a working prototype much faster.

But there was an equally important lesson.

AI is very good at writing code. That doesn't mean every line it writes is good code.

You still need to make architectural decisions, understand the output, debug unexpected behavior, and review what you're shipping.

For me, these tools didn't replace programming. They gave me more freedom to experiment.

And that was exactly what I wanted from Hacktoberfest.

Hackathon Experience

🎃 Hacktoberfest 2026 — Just Build Something!

Most of my professional work involves engineering leadership, system architecture, delivery planning, and working with teams building large-scale applications.

But sometimes, I miss simply opening an editor and building something for no other reason than curiosity.

Hacktoberfest gave me that opportunity.

There were no client requirements or product roadmaps driving these four experiments.

Just ideas I wanted to explore.

And the variety made it even more enjoyable.

One project took me back to childhood television. Another tackled a real problem in job hunting. A third brought back my first programming language. And the fourth let me explore the world of local AI.

❤️ What I'll Remember Most

Of all four projects, 1988.in is closest to my heart.

I didn't build it to start a company or solve a big industry problem.

I built it for my kids.

I wanted them to experience something from my childhood, when watching TV was about discovering what was playing rather than deciding what to watch.

And watching them enjoy their little time-travel experience was priceless.

The 1,500+ active users were an unexpected bonus.

Especially considering those 9 Peerlist upvotes! 😄

I still don't know how everyone found the project, but I'm happy they did.

Maybe the best projects aren't always the ones with elaborate business plans or complicated technology.

Sometimes, they're the ones built out of curiosity, memories, and a little bit of love.

I started programming more than 30 years ago because seeing something come alive on a screen felt magical.

Today, I have Cursor, Codex, Ollama, and technologies I couldn't have imagined back then.

The tools have changed. The joy of building hasn't.

And that's what I'll remember about Hacktoberfest 2026.

Keep learning. Keep experimenting. Keep building. 🚀

Happy Hacktoberfest! 🎃

hacktoberfest #opensource #devchallenge #mlh #buildinpublic #cursor #codex #ollama

Ghost BASIC: the dead language still runs, and Gemma has to learn its dialect

Tushar Vaghela — Tue, 27 Oct 2026 16:34:29 +0000

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

What I Built

Ghost BASIC is a small BASIC environment you run in a terminal. The ghost is the language.

Numbered BASIC is the dialect people met in school computer labs: line numbers, FOR/NEXT, PRINT, a program that fit on one screen. Those machines are gone. The programs are not. Ghost BASIC loads a .bas file, including old DOS text, and runs it. Press F5 and it prints. Press F1 and it opens an offline reference for the dialect it actually implements.

Week 4 asked for something spooky, or something that keeps a memory alive. I took the second reading. The first one is painted on the splash screen: an ASCII ghost crosses the terminal, then gets out of the way. What remains is an editor.

Code Magic, on F8, is the optional companion. It can debug, explain, write, or suggest. The default model is Gemma 4 31B (gemma4:31b) through Ollama Cloud. It does not get to invent a richer BASIC than the one on the left. A proposal is compiled locally, and applied only after you review the diff.

Many entries this week put a spirit in the shell. An offline séance with ALGOL 60 keeps a dead language honest by refusing to let the model speak past a curated record. Ghost BASIC is the other half of that idea: the language is executable again, and the model has to write something the runtime will accept.

This is a numbered-BASIC subset, not a finished GW-BASIC or QBasic. QBasic procedures can be opened and read. They cannot run yet.

Demo

Ghost BASIC is a terminal program, so the live site is a tour with real screenshots, not a hosted interpreter:

https://tusharv.github.io/GBASIC/

Python 3.12 or newer. No account for the editor, the examples, F1 help, or Run. Code Magic asks for your own Ollama Cloud key the first time you open it.

git clone https://github.com/tusharv/GBASIC.git
cd GBASIC
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -e '.[dev]'
GBASIC

Then F3, choose fibonacci.bas, F5. Answers to INPUT go in the bottom field. F6 stops a run. GBASIC --no-splash skips the ghost.

The syntax check around Magic is tested with an in-process stand-in for the HTTP call. I did not have an Ollama key in the build environment, so a live model reply is something you will see with your own key. I am not pasting one here as a recorded run.

Code

MIT licensed. The interpreter does not phone home. Magic contacts the network only when you press Send.

tusharv / GBASIC

Ghost Basic - Python based version of classic QBASIC

Ghost BASIC

An independent MIT-licensed BASIC environment for Python 3.12+. Version 0.4 includes a full-screen ASCII terminal editor, searchable keyword help, a tested BASIC interpreter and optional Code Magic powered by Ollama Cloud It is not yet a complete GW-BASIC or QBasic implementation.

Screenshots

Real captures of the running terminal application. The ghost moves in the app; its image below shows one frame of the startup animation.

Editor and program output

Startup splash and flying ghost

See the examples picker and keyword help

Visit the Ghost BASIC website. The landing page source and GitHub Pages deployment guide are included in this repository.

Launch the terminal UI

After installation and activating the environment, launch from the project folder with:

GBASIC

The package installs both GBASIC and ghost-basic commands. You can also launch directly with .venv/bin/GBASIC (Windows: .venv\Scripts\GBASIC.exe).

A startup splash displays Ghost BASIC with a flying ASCII ghost…

View on GitHub

examples/fibonacci.bas:

10 A=0: B=1
20 FOR I=1 TO 10
30 PRINT A;
40 T=A+B: A=B: B=T
50 NEXT I
60 PRINT

The editor, the runtime, and the 175-topic help stay on the machine. Send is the only arrow that leaves: one fenced program comes back, the local compiler checks it, and you apply the diff yourself.

How I Built It

Ghost BASIC is Python 3.12. The terminal UI is Textual. Execution, file loading, and help need no model and no network. Help covers 175 topics, and anything not implemented is marked that way.

Old files are part of the point. Open accepts UTF-8 and falls back to DOS CP437, including box-drawing characters and a trailing Ctrl+Z. Save writes UTF-8 and does not rewrite the original just because you opened it.

Code Magic calls Ollama's chat endpoint. The default model name is gemma4:31b. You can type another Cloud model name. The key is stored in the OS credential vault (macOS Keychain, Windows Credential Locker, or a Linux secret service), not in a project file.

The model has no shell, no filesystem, and no permission to run the program. Each Send can include the open filename (not the folder), the source, and the last 6,000 characters of that run's output. Turn Context off and those stay behind. The prompt lists the implemented statements and tells the model not to invent RND, procedures, or graphics.

If the reply contains exactly one basic fence, Ghost BASIC compiles that source and does not execute it. A syntax error triggers one correction request. A second failure is shown to you. Apply appears only after you open the diff. Ctrl+Z undoes it. F5 is how you learn whether the program does what you asked. A clean compile is not proof of behavior.

That constraint is the project. A general model will happily write QBasic. Ghost BASIC cannot run QBasic procedures. The interesting failure is a fluent program the interpreter rejects.

Why Does Open Innovation Matter?

A closed chat API could explain a FOR loop. It could not be the language.

The interpreter, the help, and the examples stay on the machine. A classroom or a folder of old .bas files does not need an account. If the model host disappears, PRINT still prints. That is the part a closed API cannot offer: the artifact outlives the service.

Magic does use a service, and that limit should be plain. It needs a network and an Ollama Cloud account. It does not run with the cable pulled. What the open-weight model changes is the contract around that call:

The default brain is Gemma, named in settings as gemma4:31b. Swapping the model name does not mean rewriting the interpreter.
The dialect rules live next to the compiler that enforces them. A vendor cannot silently widen BASIC with features this runtime does not have. The local check sends those answers back.
You can read the prompt, the size limits, and the one-correction rule. Apply is a diff against the editor, not a hidden write.
Only the open buffer and a slice of output go out, and only when you press Send.

A closed assistant would still draw a triangle of asterisks. It would also be free to describe a language I did not build. Here the language is the repository. The model is a guest that has to pass the compiler.

The Spirit of It

The splash ghost is a joke that lasts a few seconds. The part that stayed is quieter.

Open a file saved on a DOS machine. The line endings are wrong for a modern editor, the box-drawing characters are in CP437, and the file may end with the Ctrl+Z those programs used as an end mark. Ghost BASIC reads it, leaves the original bytes on disk, and shows numbered lines you can run.

That is the offering. Not a story about the person who typed 10 PRINT. The program itself, still willing to print.

Prize Categories

Best Use of Gemma. Code Magic defaults to gemma4:31b on Ollama Cloud. The prompt, the one-shot syntax repair, and the apply path are built around that open-weight model, and the name can be changed. Inference is hosted. This is not a local Gemma runtime.

Local LLM Studio: chat and a speed check that stay on the laptop

Tushar Vaghela — Sat, 24 Oct 2026 19:18:41 +0000

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

I wanted a local model for the boring stuff: drafting a reply I do not want in someone else's log, checking whether a screenshot is readable, and finding out if a 3B model is actually usable on this laptop. What I had instead was three apps, three ports, and a terminal I had to babysit.

Local LLM Studio is the slow version of that workflow. It sits on 127.0.0.1 and talks to whatever open model server is already running.

What I Built

Local LLM Studio is a small private front end for a model server on your own machine. It speaks the OpenAI-compatible /v1 API, so the same install works with Ollama, LM Studio, and llama.cpp's llama-server.

Four jobs, and then it gets out of the way:

Setup tells you whether the saved server answers, and prints the install and start commands for macOS, Windows, or Linux. You copy those commands into a terminal yourself.
Chat streams a reply and reloads the same transcript after a refresh. Image attach shows up only when that model is marked as able to see.
Models lists whatever GET /v1/models returns. On Ollama it can also pull a model, delete one, and read the native vision flag. Pull and delete stay hidden for LM Studio and llama.cpp, because those runtimes load weights themselves.
Benchmarks run one model at a time and record time to first token and tokens per second for this server and this tokenizer. A discarded warmup is on by default, because the first sample is mostly the runtime loading weights.

The person who gets to be lazier is anyone who keeps a local model around for private drafts and then loses twenty minutes remembering which port is which. Studio binds to 127.0.0.1:8000. Chats, uploaded images, and benchmark rows stay in a ./data folder next to the app. There is no account and no telemetry.

A loopback server URL is saved immediately. A private-network URL is saved only after you confirm it, because the prompt then leaves the machine. Public cloud hosts, including https://api.openai.com/v1, are rejected.

Demo

There is no deployed link, and that is the product. Studio listens only on loopback, and the URL check turns a public host away.

python -m pip install -e ".[dev]"
cd web && npm install && npm run build && cd ..
python -m studio

Open http://127.0.0.1:8000. On Windows, localhost often resolves to IPv6 while Studio listens on IPv4, so use the numeric address.

Setup

Benchmark

Chat

Code

MIT licensed. The repo is tusharv/local-llm.

tusharv / local-llm

Tool to Setup and Run LLM Locally

Local LLM Studio

Local LLM Studio is a private chat, model list, vision check, and speed benchmark for a model server running on your own machine. It speaks the OpenAI-compatible /v1 API, so it works with Ollama, LM Studio, llama.cpp, and any other local server that implements those routes. Ollama is a preset that can also pull a model, delete a model, and read native vision flags.

Studio binds to 127.0.0.1:8000. Chats, images, and benchmark rows stay in ./data. It does not install or start Ollama, LM Studio, or llama.cpp. The first run prints the commands for your operating system. You copy them into a terminal yourself.

The same Studio install is used on macOS, Windows, and Linux.

A plain explanation of why Studio exists, and who it is for, is at https://tusharv.github.io/local-llm/.

Install Studio

You need Python 3.11 or newer and Node.js 20 or newer.

python

…

View on GitHub

The privacy claim is a URL check in studio/url_policy.py. Loopback is saved immediately. A private LAN address needs an explicit confirm, because the prompt then leaves the machine. A public host is refused and the database is left unchanged.

How I Built It

The open-source AI in this project is the model server, not an agent framework. Studio ships no weights. It assumes you already run an open-weight model through one of three local runtimes:

Server	URL you save	What Studio may do
Ollama	`http://127.0.0.1:11434/v1`	Chat, list, pull, delete, read vision capability
LM Studio	`http://127.0.0.1:1234/v1`	Chat and list. Load the model in LM Studio.
llama.cpp	`http://127.0.0.1:8080/v1`	Chat and list. Start `llama-server` yourself.

Suggested Ollama pulls in the UI include Llama 3.2, Qwen 2.5 Coder, and Gemma 3 4B. Those are starting points for an 8 GB or 16 GB machine. Any other tag in the Ollama library works the same way.

flowchart LR
  browser["Browser at 127.0.0.1:8000"] --> api["FastAPI"]
  api --> db["SQLite and uploads in ./data"]
  api --> v1["OpenAI-compatible /v1"]
  v1 --> ollama["Ollama :11434"]
  v1 --> lm["LM Studio :1234"]
  v1 --> llama["llama-server :8080"]

The API is Python 3.11, FastAPI, and uvicorn. Chat, images, and benchmark rows go into SQLite under ./data. The UI is React and Vite, built once and served by the same process. python -m studio --dev runs the API and Vite together while the interface is changing.

Ollama gets a second, native client on the same port. Its OpenAI routes hide pull progress, delete, and the vision capability flag, so those calls use Ollama's own HTTP API. For every other server, vision comes from a known family name, a one-shot vision probe, or an override you set.

Benchmarks are a fixed suite, version 2, with three profiles: a general mix, code generation, and one image-generation prompt. Generated code is shown as text and never executed. Image URLs are never fetched. Repeats are 1 or 3. Reports show median response time and effective throughput: output tokens divided by the full request duration, including the wait for the first token.

Two write-ups shaped those choices. Theo Slater built a desktop chat app that talks only to Ollama, and wrote that an OpenAI-compatible API should have been there from the first day: I Built a Desktop Chat App for Running Local LLMs Offline. Studio starts from that API, so LM Studio and llama.cpp are a URL change. Sam Hartley is blunt that local models still lose on long reasoning, stale knowledge, and finicky vision: I Replaced All My Cloud AI With Local Models — Here's What Actually Broke. The benchmark page exists so that failure shows up on your own hardware.

Why Does Open Innovation Matter?

A closed chat API can answer the prompt. It cannot be the thing this project is for.

The weights are open, so Llama, Qwen, and Gemma can be swapped with no new vendor SDK and no per-token bill. The servers are open, so the same client reaches three runtimes. Inference stays on the machine, so a transcript about a half-finished idea stays in ./data.

A hosted API would also make the speed number meaningless. Tokens per second is a memory bandwidth number, as @lowspecai put it: each token reads the weights, so the ceiling is how fast your RAM or VRAM can be read. A leaderboard from someone else's GPU does not say whether llama3.2:3b is pleasant on this laptop. The same prompt, run locally with the warmup thrown away, does.

Open weights are also why the lazy version can be picky. If a 3B model rambles, or a vision model calls a screenshot a flowchart, delete it and pull another one.

The Lazy Payoff

The model does not do the job. It removes the errand around the model.

Before Studio, trying one local model meant remembering the port, remembering whether this runtime wants ollama run or a loaded model in a Developer tab, pasting the prompt, then doing it again for the next model because nothing kept the transcript. Checking vision meant attaching an image and reading a confused paragraph. Checking speed meant watching the terminal and guessing.

With Studio, that errand is one saved URL. The transcript is still there after refresh. The attach button is absent when the model cannot see. One benchmark row replaces the guess. The page labels that number as speed for this server and tokenizer. Whether the answer is any good is still yours to read.

I do not have a stopwatch figure, and I am not going to invent one. If you timed a real run this week, put that row here. If you did not, delete this section before publishing.

Thanks

Thanks for the challenge, and for a theme that fits a tool whose whole job is to sit on loopback and wait.

Two products in one Hacktoberfest: a retro TV Experience and a CV that won’t invent your past

Tushar Vaghela — Tue, 13 Oct 2026 09:38:22 +0000

This is a submission for the MLH x DEV Writing Challenge

Hacktoberfest this year asked me to ship, not just to open pull requests. I ended up with two live products that sit on opposite ends of the same idea: software that respects the person in front of it.

1988.in is a television. It does not ask what to watch next.
Job Ready is a CV tool. It does not invent experience you never had.

One is for my kids on the sofa. The other is for someone staring at a job post at midnight. Both came out of MLH / DEV challenge windows in October, with Cursor as the coding partner and real partner platforms underneath.

What I Built

1988.in — Feel era of 1988. No skip.

Streaming apps train a thumb to leave. A clip has a few seconds before you decide it owes you a different clip. I missed the other feeling: a set that is already on, mid-programme, with nothing under the glass except the picture.

1988.in is that set. You accept a short station notice, press the glass, and land in the middle of whatever is on air. Bollywood is on 001. Cricket is on 002. Jungle Book, Shaktimaan, Ramayan, and the other Doordarshan-era shows live under DD Era, next to nature, food, sport, and quieter channels you can leave running. Nobody picks “what to watch next.” The channel is simply on.

The piece that makes it feel like a broadcast is a clock. The same channel, the same catalog, and the same UTC second always resolve to the same video and the same start time. Two people who turn the set on in different rooms are watching the same programme, already underway. A phone can be the remote over a WebSocket: the picture stays on the computer; the phone only sends the button press.

I built it for my kids. When I handed it over, they said: “Interesting.” That was enough.

Job Ready — show why you fit, one role at a time

Most AI résumé tools have the same failure mode: they rewrite until the CV sounds ready, including experience you never did. That problem shows up again and again on DEV — from grounded resume editing to pipelines that validate and scrub LLM output. I wanted the opposite product.

Job Ready checks one existing CV against one job. Upload a text PDF or DOCX, paste a role, and get exactly one of two results:

Ready to send: a fact-checked rewrite, a fit report, and a downloadable PDF.
Gaps to close: a practice plan for required skills the work history does not show yet. No rewritten CV. No PDF. No advice to list a skill you have not done.

Gemma (via Ollama) extracts structure, quotes evidence, and rewrites wording. Python decides suitability. A skill only counts when a work bullet quote matches the saved text, or when the skills list contains the phrase. Employers, titles, dates, degrees, tools, and numbers cannot change. Failed fact checks are not saved.

A missing skill on a CV is not always missing experience. Sometimes the work was real and the bullet was thin. From a flagged gap you can open a private “Update my CV” chat, explain what you actually did, review Gemma’s proposal, confirm accuracy, and reassess. The model proposes; the person confirms; code re-scores.

Demo

Television

Open https://www.1988.in/, choose Watch TV, and turn the set on. You should arrive mid-programme, with YouTube’s controls gone.
Press CH +. Snow, then a different station, also already in progress.
Open Channels, search “Ramayan” or filter by DD Era, and tune in.
Choose Connect remote, scan the QR from a phone, and change the channel. The desktop moves. The phone never shows the video.

Source: github.com/tusharv/positive-player

Earlier write-ups: Feel 1988. No skip. · A television with no skip button

Job Ready

Open https://jobready.tech/, create an account, and upload a text-based PDF or DOCX.
Paste a role title and job description.
Read the result: Ready to send or Gaps to close.
If a preferred skill is missing (for example pytest), try Have this experience? Update your CV. Write what you actually did, review the proposal, confirm, then Apply & reassess.

Source: github.com/tusharv/green-grass

Challenge write-up: Job Ready: Tailor Your CV Without Inventing Your Experience

Partner Technologies

For 1988.in — YouTube Data API and Vercel

Playback is the YouTube IFrame Player. Video bytes never touch my server. The expensive problem was the guide.

YouTube’s daily search quota is tiny. A hundred-channel lineup driven by search.list would die in one flip-through. I moved every station to a curated JSON catalog of video ids. A generator script refreshes metadata when I ask it to — never as part of npm run build. Playback works with no API key; when a key is present, it only re-checks that bundled ids are still embeddable.

The television itself is a static Vue 3 / Vite / Pinia app on Vercel. The phone remote needs a public WebSocket, so vercel.json rewrites /remote-ws to a Function that holds an in-memory pairing hub. The desktop is authoritative. The phone sends channelStep, volumeStep, mute, and power. Sessions live in that process; video never passes through it. Locally the same hub runs in Node with a Vite proxy.

That split taught me something I keep repeating: the product is the clock and the remote protocol, not a programme database.

For Job Ready — Gemma, Render, and a .tech domain

Gemma (gemma4:31b through Ollama) runs the language work: CV extraction, job-skill extraction, evidence quotes, rewrites, gap plans, and clarification edits. Suitability stays in fit.py. Fact checks stay in facts.py. Chat proposals stay grounded in the person’s exact messages in cv_chat.py.

Render hosts the FastAPI + Svelte 5 app and PostgreSQL. A Blueprint in render.yaml wires the web service, database, health check, and env so a redeploy is a checkout plus an Ollama key — not a day of clicking console forms.

jobready.tech is the public address. The name matches the promise: one role, an honest next step, not a match-percentage theatre.

Open weights matter here because CV extraction, evidence screening, and conversational edits fail in different ways. I can swap or tune the model while keeping scoring and confirmation as application rules — the same instinct as production LLM validation posts on DEV, applied to someone’s career story.

Hackathon Experience

October was a stack of MLH surfaces, not one weekend in a gymnasium.

I checked in at Hacktoberfest Hack Day Mumbai x FAIR, stayed registered for Hacktoberfest 2026 and Global Hack Week: Hacktoberfest, and shipped into the DEV challenge windows: the Weekend Challenge for 1988.in, then Week 2: Side Hustle for Job Ready.

What I will remember most is the contrast in the room and on the screen. At the Hack Day the energy was familiar MLH: people pairing, demos half-working, someone hunting a cable. Online, the challenges forced a sharper question each Monday — build for a friend, then build something someone might pay for. 1988.in answered the first with a set for my kids. Job Ready answered the second with a product I would actually trust with my own CV.

The technical moments that stuck:

Two browsers on 1988.in, same channel, same second of the same video, with no server choosing the schedule. That was the first time it felt like television.
A Job Ready assessment that refused a “ready” PDF because a quote did not match the source bullet. Annoying in the moment. Correct for the product.

If you are in an MLH week right now: ship the weird small thing and the serious useful thing. Write both up. The weekend ends; the story is how other builders learn what you learned the hard way.

Job Ready: Tailor Your CV Without Inventing Your Experience

Tushar Vaghela — Tue, 13 Oct 2026 06:39:54 +0000

Job Ready: An Honest Next Step for Your Next Role

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

What I Built

I built Job Ready, an app that checks your existing CV against a specific job and helps you take the next step without inventing experience.

Upload a PDF or DOCX, paste the role title and job description, and get one of two results:

Ready to send: a fact-checked CV rewrite, a fit report, and a downloadable PDF.
Gaps to close: a practice plan, with missing required skills listed before missing preferred skills.

But a missing skill on a CV does not always mean missing experience. Sometimes you have done the work and simply left it out.

Job Ready addresses that through a private “Update my CV” conversation. From a flagged major or minor gap, you can explain what you actually did. Gemma proposes changes supported by your statements, you review and confirm their accuracy, and the application updates your CV and reassesses that role.

That creates a useful loop: assess the CV, surface missing evidence, clarify real experience, and check again. If you still have a gap, the practice plan gives you something concrete to work on.

The intended customers are job seekers preparing several applications and career coaches helping clients describe their experience clearly. My business hypothesis is that they would pay for less repetitive editing, evidence-backed CV updates, and focused preparation for each role. Paying-customer demand still needs validation.

Demo

Try Job Ready.

Create an account, upload a text-based PDF or DOCX CV, and paste a job description.

Here is one example of the clarification flow:

The assessment flags pytest as a missing preferred skill—a minor gap.
The person selects “Have this experience? Update your CV.”
In the private conversation, they write: “I have worked with pytest.”
Gemma proposes adding pytest to the skills list by asking some questions.
The person reviews the proposed edit and confirms that it accurately describes their experience.
“Apply & reassess” saves the change and runs the role check again.

The same flow is available for missing required skills, which are marked as major gaps. An update does not automatically make someone ready: the application calculates the result again using its existing rules.

The person can also choose to refresh their shared profile. Other saved role checks retain their previous assessments.

Code

The code is available on GitHub:

tusharv / green-grass

Your next role. An honest next step.

Job Ready

Job Ready, at jobready.tech, checks one CV against one job. A signed-in person uploads a text PDF or DOCX, pastes a role, and gets one of two honest results: a fact-checked CV they can download as a PDF, or a practice plan for required skills the work history does not show.

The model extracts structure and rewrites wording. It does not decide whether the CV is ready, and it does not invent employers, titles, dates, degrees, tools, or numbers. Suitability is scored in code.

What you get

Upload a text PDF or DOCX. The original file is discarded. The server keeps the extracted text and a structured profile.
Paste a role title and job description.
The server pulls required and preferred skills from the posting, then scores the saved profile.
Ready to send when the score clears the bar: a rewritten CV, the fit report, and a…

View on GitHub

The main pieces are:

app/services/pipeline.py — coordinates extraction, assessment, and the resulting CV or gap plan.
app/services/fit.py — validates supporting quotes and calculates suitability.
app/services/facts.py — checks generated CVs and gap plans before saving.
app/services/cv_chat.py — restricts proposed CV edits and grounds them in the person’s statements.
app/cv_chat_routes.py — manages private conversations, confirmation, and applying updates.

How I Built It

Job Ready uses Gemma through Ollama, with gemma4:31b as the configured default model.

Gemma handles the language tasks throughout the workflow:

Extracting a structured profile from CV text.
Extracting required and preferred skills from a job posting.
Identifying work-history quotes that support a skill.
Rewriting existing experience for the target role.
Creating practice plans for missing skills.
Turning user-provided clarification into proposed CV edits.

Keeping assessment grounded

The suitability decision belongs to Python code.

The application combines required-skill coverage and years of experience using a fixed formula. Work-history quotes must match the saved source text. Skills-list matches are checked in code, and preferred skills do not block suitability.

Gemma helps interpret and express information, while the application controls which evidence is accepted and which result is available.

Generated CVs also pass through fact checks. Protected facts such as employers, titles, and dates must remain intact. Contact details and education come from the saved profile. Failed checks are not saved.

Clarifying experience before changing the CV

The private chat handles an important distinction: “not evidenced in your CV” can mean either missing experience or missing information.

Gemma proposes edits from the conversation, and server-side checks require supporting text from the person’s messages. Added skills must be explicitly supported. Work-history changes require the employer to be named, and new numbers need source support.

For example, “I have worked with pytest” can support adding pytest to the skills list. It does not establish which employer used it, how long the person used it, or what measurable results they achieved.

Proposals remain unsaved until the person reviews them, confirms their accuracy, and selects “Apply & reassess.” Applying a proposal updates the source CV and current assessment together, with an optional update to the shared profile.

The chat can edit the summary, skills, and existing work bullets. It cannot change identity fields, education, or total years of experience. The original extracted upload text remains unchanged.

These checks validate that a proposed edit is supported by the person’s statements. They do not independently verify that the experience happened.

The application stack

The interface uses Svelte 5, with FastAPI and Pydantic handling the backend and structured data.

pypdf and python-docx extract CV text. WeasyPrint generates PDFs for ready results. The original uploaded file is discarded after extraction; extracted text and a structured profile are retained.

The app uses SQLite locally and PostgreSQL on Render. FastAPI serves the built frontend, keeping deployment within one application.

Automated API tests use scripted model responses so the application’s rules can be checked without calling a live model.

Why Does Open Innovation Matter?

For Job Ready, open innovation means having room to improve the model behind a very specific workflow.

CV extraction, evidence screening, and conversational edits have different failure modes. A model might rewrite a sentence well but infer too much from a short statement about someone’s experience. Open weights create the opportunity to evaluate alternative models and explore targeted tuning for those tasks.

The model and host are configurable, while scoring, evidence checks, and confirmation remain application rules. That separation gives me a way to evolve the AI component while keeping the product’s constraints explicit.

The current configuration uses Ollama’s hosted service. I am not claiming that CV processing happens entirely on the user’s machine. Running inference on infrastructure I control is a future option that open weights make possible.

A closed API could implement this workflow too. The additional value of open weights is the ability to work directly with the model, explore self-hosting, and investigate improvements beyond a provider’s hosted interface.

For a potential paid service handling personal career information, that flexibility matters: it gives me more choices about deployment, operating costs, and how the system develops.

Prize Categories

Best Use of Gemma

Gemma is central to the complete application journey: extracting the CV, understanding job requirements, finding supporting evidence, rewriting grounded content, and producing practice plans.

It also powers the private clarification flow for both major and minor gaps. When someone has relevant experience that their CV omitted, Gemma turns their explanation into proposed edits. Server-side checks ground those edits in their exact statements, and explicit user confirmation is required before anything is applied.

The pytest example shows this in practice: a missing preferred skill becomes a proposed skills-list addition supported by the person’s own words. The application then reassesses the role using its deterministic scoring rules.

This combines Gemma’s language capabilities with evidence checks and human review at the point where personal claims change.

Best Use of Render

Render hosts Job Ready’s FastAPI backend, Svelte interface, and PostgreSQL database.

I also added a Render Blueprint in render.yaml to make deployment straightforward. It defines the web service, database connection, health check, and environment configuration, so someone deploying the project does not have to configure each resource manually.

With the repository and an Ollama API key ready, setup takes around five minutes, plus build and provisioning time.

The deployed backend handles CV processing, Gemma requests, private clarification conversations, saved assessments, and eligible PDF downloads.

Best Use of a .tech Domain 🆕

Job Ready is live at jobready.tech, giving the project a clear, memorable address that matches its purpose: helping people prepare for their next role.

The domain brings the complete experience together—from uploading a CV and checking a role to clarifying experience with Gemma and sharing a profile with employers.

A television with no skip button

Tushar Vaghela — Wed, 07 Oct 2026 19:18:06 +0000

This is a submission for the MLH x DEV Writing Challenge

What I Built

Reels trained my thumb to leave. A clip has a few seconds before I decide it owes me a different clip. I missed the other feeling: a television that is already on, in the middle of something, with nothing under the glass except the picture.

1988.in is that set. You press the glass to turn it on and land in the middle of whatever is on air. There is no progress bar and no next clip waiting. If you want a different picture, you change the channel.

The lineup opens the way an evening in India used to. Channel 001 is Bollywood. Then cricket, Jungle Book, Shaktimaan, a month of DD Classics, Ramayan, and Mahabharat. After those come animals, street food, space, sport, and travel, and then the quieter stations: rain, a hearth, a forest, a lake. Channel 013, Vintage India, is a curated run of old advertisements, public-service films, and broadcast interludes — 198 videos, kept short on purpose, about two hours and fifty minutes from start to finish. The full set is 125 channels. Each one ships as its own list of YouTube video ids, titles, and durations.

1988 is the year on the glass. The programmes come from many years, and every one of them plays through YouTube. The app never downloads, rehosts, or proxies the video.

The piece that makes it feel like a broadcast is a clock. The same channel, the same catalog, and the same UTC second always resolve to the same video and the same start time. Two people who turn the set on in different rooms are watching the same programme, already underway. A catalog shorter than a day rotates its opening programme by the UTC date, so Tuesday is a different timetable from Monday. A catalog longer than a day plays straight through midnight. When a video ends, the clock chooses the next slot. YouTube's up-next row never gets a vote.

The YouTube player is real, and its controls are hidden. Scanlines, grain, and a vignette are a CSS layer on top of the iframe. A CSS filter on the iframe itself fights the player, so the glass treatment stays on a separate layer and ignores pointer events. Changing channel runs a short analog zap: snow, a horizontal tear, and the new picture already loading underneath. prefers-reduced-motion keeps still scanlines and replaces the zap with a brief dark frame. Volume lives on the glass, in steps of five. The channel and volume HUD fades after a few seconds of quiet. The first tap, arrow, or OK press only wakes it.

A phone can be the remote. The computer shows a QR code and an eight-character code. The phone joins over a WebSocket and can send power, channel, volume, and mute. The desktop answers with its real state, including changes made on the glass. Picture and sound stay on the computer. One phone pairs with each set. An invite lasts five minutes and is used up on the first join. A disconnected desktop has two minutes to return. A session lasts twelve hours. Presses made while the phone is offline are dropped. A remote that replays a stale command after it reconnects is a worse remote than one that missed a press.

The app is Vue 3, Vite, Pinia, and Vue Router. One Pinia store owns power, channel, volume, interruption, and the current slot. Components draw the set. They do not call YouTube.

A shared clock is the product. Computing { videoId, startSeconds } from UTC is what makes two browsers agree. A random pick per session would be a website with a bezel.

Search quota ends a demo. YouTube's Data API allows very few search.list calls per day. videos.list is cheap by comparison. Viewers no longer search. Each channel is a JSON file, lazy-loaded only when that station is tuned. The home page, the guide, and the phone never download those lists. Playback works with no API key. When a key is present, it only re-checks that the bundled ids are still embeddable and still have a duration.

Embeddable is a moment, not a promise. Public playlists contain private, deleted, regional, and non-embeddable videos. A catalog that played on Saturday can fail on Sunday. That channel shows an interruption card and retries. Another station is never quietly substituted. If Cricket cannot play, the set does not put on Nature and hope you will not notice.

The power button is the browser gesture and the legal gate. Sound will not start without a click. That same click is where the viewer agrees to the privacy policy, the terms, and YouTube's terms. The Data API and the iframe stay idle until then.

Nostalgia needs a boundary. I wanted the feeling of that era of Indian television. I did not put an official broadcaster mark on the glass. The site says so in the footer.

Demo

The set is live at https://1988.in/.

Choose Watch TV and turn the set on. You should arrive in the middle of a programme, with the YouTube controls gone.
Press CH + or the right arrow. Snow, then a different station, also already in progress.
Open Channels. Search "cricket", or filter by the DD Era tag, and tune in.
On the computer, choose Connect remote. Scan the QR code, or open /remote and type the eight-character code. Change the channel from the phone. The desktop moves. The phone never shows the video.

Source: github.com/tusharv/positive-player

Partner Technologies

The two platforms this project actually depends on, beyond the Vue app, are the YouTube Data API through Google Cloud, and Vercel.

YouTube Data API on Google Cloud

Playback is the IFrame Player API. That part spends no Data API quota. Catalogs are the expensive problem.

The first lineup was search queries, one per channel. Flipping through the set could burn the daily Search Queries budget, which is a separate, much smaller bucket than the general 10,000-unit pool. I moved every station to a curated bundle. A generator script runs only when I ask it to, never as part of npm run build. It checks metadata, keeps up to 50 videos for a generated channel, preserves hand-picked selections, and refuses to replace the files if any generated channel would be left with fewer than three videos. A changed bundle gets a new cache key, so a viewer's browser does not keep yesterday's list under today's name.

Two stations are hand-kept. Channel 005, DD Classics, is a 34-day rotation of serials, comedy, culture, and vintage ads. Channel 013, Vintage India, keeps the short ad spots that a "drop anything under 60 seconds" rule would have thrown away. Curated items shorter than one second are still dropped. Ordinary catalogs still drop anything under a minute.

Vercel

The television is a static build. The remote needs a public WebSocket, and a static host does not provide one.

vercel.json rewrites /remote-ws to a Function, api/remote-ws.mjs, with maxDuration set to 300 seconds. The function includes the server code, the shared protocol module, and the channel data. The hub checks channel numbers against the real lineup, so a phone cannot tune to a station that does not exist.

The function holds an in-memory session hub. The desktop creates a session and receives an id, a host token, the eight-character code, and an invite. The phone joins with the code or the invite and receives a remote token. From then on the phone sends commands (channelStep, volumeStep, digit, mute, powerOff, powerToggle) and the desktop sends state. The host is authoritative. The phone cannot write the channel except by a command the TV applies through the same store as a key on the glass. The socket's origin has to match the request host. Idle connections are swept.

The ceiling is honest. Sessions live in that one process, up to 1,000 televisions, and they disappear when the process does. Two instances cannot share one paired phone and TV. For a room of sets, that is the right shape. A remote that has to survive many instances needs shared session storage and a way to deliver a command to the process that still holds the desktop socket. Video never passes through the function. The bytes go from YouTube to the browser.

Locally, the same hub runs in Node and Vite proxies /remote-ws to it. One protocol module, two places it can run. A self-hosted box can also serve the built site and the socket from a single Node process.

Hackathon Experience

The moment from the software that I keep is a small one. Two browsers, one channel, the same second of the same video, with no server choosing the schedule. That was the first time it felt like a television.

Feel 1988. No skip. 📺

Tushar Vaghela — Mon, 05 Oct 2026 04:30:00 +0000

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

What I Built

I built https://1988.in/ for my kids.

1988.in is a television that lives in the browser. You accept a short station notice, press the glass, and the set comes on already in the middle of a programme. Bollywood is on 001. Cricket is on 002. Jungle Book, Shaktimaan, and the other Doordarshan-era shows are in the guide under DD Era, next to nature, food, sport, and quieter channels you can leave running. Nobody picks “what to watch next.” The channel is simply on.

That is the problem it solves. Streaming apps ask for an account, a search, and a decision. A television asks you to sit down. Channel, volume, and mute stay in that browser, including changes made from a paired phone. Turn the set on again and you are back on the same channel, mid-broadcast.

When I handed it over, they said: “Interesting”

Demo

https://1988.in/

On a laptop, open the TV, accept the notice, and press power. Open Channels and search “Ramayan” or the DD Era tag. On a phone on the same page, choose Connect remote, scan the QR code, and change the channel. The picture stays on the computer. The phone only sends the button press.

Code

https://github.com/tusharv/positive-player

The lineup is src/data/channels.ts. The broadcast clock is src/lib/broadcastClock.ts. The television state lives in one Pinia store, src/stores/tv.ts. The phone speaks a small WebSocket protocol. Video bytes go straight to YouTube.

How I Built It

The set is a Vue 3 single-page app: Vite, Pinia, Vue Router. YouTube’s IFrame Player paints the picture. YouTube Data API v3 fills the guide from each channel’s public uploads playlist. A Vercel function at /remote-ws relays the phone. The same relay runs as a small Node process for local development and self-hosting.

Each channel is a playlist id, not a search. A default YouTube project allows 100 search calls a day, which a hundred-channel lineup would burn in one flip-through. Playlist and video lookups sit in the ordinary quota, and a catalog younger than seven days stays in the browser.

The illusion of a broadcast is a clock. Durations in the catalog are summed into a loop. The UTC second, modulo that loop, picks the video and how many seconds into it you join. Two people who turn on the same channel in the same second join the same moment. When a video ends or will not embed, that id is dropped for the rest of the tab and the clock runs again.

The phone never touches YouTube. The TV shows a QR code and an eight-character pairing code. One phone pairs to one set. The desktop sends its real state back, so a channel change on the glass shows up on the phone, and a channel change on the phone shows up on the glass. Sessions live in memory, invitations expire, and a disconnect gives the desktop two minutes to return.

I built it with Cursor, from a written spec through to the Samsung TV fix in 0.4.1. On those sets, YouTube draws on a separate hardware plane, so a full-screen scanline layer hides the picture while the sound keeps playing. The player detects that and turns the glass effects off. That was a coding agent helping me write a website. The running programme does not call a model.

Why Does Open Innovation Matter?

The part a family actually touches is open because it is a web page.

There is no account on 1988.in. Power, channel, and volume stay in the browser that is sitting in the room. The remote is another browser tab. Pairing credentials stay in that tab. A closed streaming app would have put the lineup, the history, and the remote behind a login on someone else’s server. Here the lineup is a file in the repository. The schedule is arithmetic on UTC, so there is no programme database to run, pay for, or lose. Video stays on YouTube, which is the closed piece, and the television around it can be read, changed, and self-hosted.

What that made possible is a set you can leave on for someone who does not want another app. They press the glass. Something is already playing. They pass the phone across the sofa.

My Agent Session

The design spec and the implementation notes are in the repository under docs/superpowers/ and docs/architecture.md.