Questions turned into software.

The profile repository is the index to my work rather than a standalone product: current projects, published packages, collaborative experiments and links to their source. It connects the public name Muneer Alam with muneer320 and distinguishes maintained tools from historical prototypes. The README is a navigation and identity surface, not evidence of product adoption. Its current-work statements and repository totals should be reviewed when projects move or change status; linked source remains the place to inspect implementations and contributor history.

A forked web-interview guide developed into an interactive practice site. Predict JavaScript output before revealing the explanation, explore visual teaching models, rehearse a STAR story or run a timed mock round. Astro builds the Markdown lessons and Pagefind search; React tools keep checklists, drafts and attempts in the current browser. Upstream authorship remains credited. Pagefind indexes the generated production HTML, while a modular widget host mounts interactive practice tools. Checklists and self-scores are personal study aids, not a measured hiring assessment; clearing browser storage can erase progress, so exports provide a useful way to retain a story draft.

An archived college interface assignment that recasts portfolio sections as a cyberpunk game menu: a character dashboard, mission cards, procedural sounds, a hidden terminal and a Simon-style memory game. The experiment is in navigation and atmosphere. Its scores and sample project cards are historical demonstration content, and the animated contact form does not send messages. The preservation boundary matters: old skill levels, game scores and placeholder destinations are part of the assignment, not current career claims. The source is useful for examining how focus, motion, sound and alternate navigation affect the feeling of an otherwise familiar information site.

Built for the SST 2029 batch before an official tracker existed, this React viewer made the weekly schedule easier to navigate by group, course, instructor and room. A Python collection step turned the spreadsheet into JSON, leaving the browser independent of Google credentials or a live backend. The college later supplied its own tracker; the archive preserves a 2025 snapshot. The group A/B/C selection, search and remembered theme are small conveniences aimed at one specific college workflow. Keeping collection outside the React viewer also means the preserved schedule can be explored after the source spreadsheet or original hosting stops being available.

Team Underdawgs explored how field context, a crop season and its day-to-day records could support agricultural decisions. The contribution case study now includes a synthetic local demo: register a field, journal observations and spending, and review the evidence or missing inputs behind planning screens. React, a Python API and PostgreSQL run together; unavailable model recommendations remain explicitly unavailable. The public contribution case study ties Muneer’s field dashboard, onboarding, phone-auth interface, conversational confirmations and season records to specific commits. Team members retain their original credits. Real agronomic recommendations, model extraction and outbound messaging require external configuration and domain review beyond the synthetic demo.

A consequence notebook for questions that start with “what if?” Instead of flattening a hypothetical into one confident paragraph, it shows connected effects, time horizons, sectors and competing fictional perspectives. Follow another assumption into a separately saved branch and compare it with the original. The collaborative prototype includes authored offline examples; optional live generation is exploratory rather than calibrated forecasting. The supported interface is a new consequence-notebook implementation over retained and repaired typed generation services. Authored demo scenarios need no provider keys; optional private live mode uses schema validation and repair. Fictional perspectives illustrate competing interests rather than real interviews or expert consensus.

A Teams-inspired collaboration experiment with two distinct sides: a SQLite-backed chat application and an isolated task environment for agents. People can register local accounts and exchange messages; a Python baseline can act through five scripted teamwork tasks and observe rewards. The simulator demonstrates an explicit task contract, with no claim that a trained reinforcement-learning policy operates the web chat. The chat polls saved direct messages; the simulator instead owns isolated episode state with explicit task completion conditions. Five baseline scenarios exercise greeting, exploration, participation, meetings and social behavior. Keeping these two surfaces distinct makes it possible to inspect what the demonstration proves without suggesting the agent controls the chat UI.

ChemPath turns organic conversions into a graph a learner can inspect. Search a compound by name, formula or alias, select a start and target, then compare stepwise routes with reagents and conditions. React and a read-only FastAPI service use a checked-in teaching dataset of 21 compounds and 23 reaction variants. Route costs illustrate traversal, not laboratory yield, safety or synthesis validation. The pathfinder considers up to ten loop-free routes and limits traversal to six steps. Its teaching-cost ordering is a readable graph heuristic. A learner can inspect why one conversion connects to another, while the small dataset’s incompleteness remains clear instead of masquerading as a synthesis-planning engine.

The original standalone React interface for ChemPath preserves an earlier stage of the same idea: browse compounds and inspect the reactions connecting two choices. Its old separately hosted backend is no longer the runnable reference. The integrated ChemPath repository now keeps the interface, read-only API and teaching graph together, while this archive preserves the frontend history. This is one project at two stages, rather than a second chemistry product with a separate set of capabilities. Its source remains useful for comparing the earlier API-dependent interface with the later self-contained teaching demonstration and for preserving the original commit history.

A collaborative financial-literacy prototype built around learning by trying: buy fictional assets with paper cash, record income and expenses, inspect saved balances and explore illustrative projections. React connects to a Python API and user-scoped SQLite records, so a refresh retains transactions. The market uses fixed fictional examples; the project places no real orders and supplies no market forecasts. The demonstration starts with fictional paper cash and a small fixed-price asset list. Backend transactions update cash and holdings together and reject overspending or overselling. Built-in learning explanations work without an AI key; optional generated text does not convert the example market into live financial information.

One HTTP interface gathers public ratings from AtCoder, Codeforces, CodeChef and LeetCode for the SST Lounge community tools. Platform-specific fetchers preserve the meaning of unrated and unavailable profiles, while single and bounded batch endpoints return explicit input, upstream and rate-limit states. It is a maintained local service for a historical community, rather than an invented cross-platform average. Single and batch requests share the same platform fetchers; batches are bounded at twenty handles. Unrated can be null and an unavailable upstream can be an error, preserving the distinction between a person without a rating and a network scrape that did not succeed.

Built for the Replit Vibeathon, Oratio gives a debate a shared room: a topic, participants, rounds, live updates, saved turns and spectator reactions. Its Python/React prototype supports local text exchanges without a model key; configured Gemini features add judging, a training opponent and audio transcription. Logic, credibility and rhetoric are evaluation prompts, with failed judging kept visibly unjudged. Participants can register disposable accounts and conduct a real local text exchange without a provider. Optional scoring evaluates logic, credibility and rhetoric, but a missing or failed model evaluation does not invent a winner. Saved room data and recorded audio make data handling an explicit deployment consideration.

An archived BlockTrain team prototype exploring two separate ideas: ERC-20 tokens associated with repository names, and YES/NO markets on pull-request outcomes. A local Hardhat demo deploys contracts, exercises minting and resolves a synthetic market. Outcomes are supplied by contract owners; the code does not verify GitHub ownership or PR status, and it is an unaudited experiment using test ETH. A repository token is not a token for every pull request, and a merged PR does not automatically pay token holders. The Solidity contracts trust their owners to supply market outcomes. Showing mint, resolve and claim on a local chain keeps those mechanics inspectable without suggesting audited public-finance behavior.

An archived take-home experiment that turns a receipt image into a draft record people can correct. The Next.js interface exposes merchant, date, line items, taxes and totals, checks their arithmetic and saves reviewed fields with the original image in local JSON storage. Extraction uses configured Gemini/Groq providers. The useful interaction is the review step, rather than treating generated fields as authoritative. The form exposes taxes, discounts and tips alongside item totals so an extraction draft can be checked as a whole. Original images and corrected fields stay in local records. Live extraction depends on a configured provider and image quality; the no-key interface screenshot demonstrates review layout rather than parser accuracy.

Book Of Organized Puzzles began as a Python CLI for turning topic-organized words into a printable word-search book. It assembles covers, topic sections, randomized grids and answer pages through an SVG-to-PDF pipeline. The placement routine builds on Christian Hill’s SciPython work. This original CLI is archived; BOOP-web carries the later interface, browser game and continued development. The original program separates word pools, grid placement, SVG drawing and PDF book assembly. Random placement has no seed control in the legacy CLI. The archive retains normal, hard and shaped bonus puzzles, with explicit errors for an insufficient word pool or a puzzle that cannot be fitted.

A personal Telegram bot puts expense entry where the conversation already happens. Send an amount, a description, a #category and optional @notes, confirm the parsed entry, then inspect or correct the shared Google Sheet ledger from chat. Parsing handles common numeric separators; list filters and summaries reuse the same stored rows. Access is restricted to configured users, not isolated per-user accounts. Number parsing accepts separators such as 1,200 and 1,20,000, while date and category filters operate on the actual sheet rows. This keeps the final ledger editable outside Telegram. It is one shared sheet for allowlisted users, so access control does not imply a separate private ledger for every participant.

An unofficial bot for the SST Batch ’29 Discord lounge brought contest schedules into the place people talked. It fetches clist.by events, stores stable records and notification history in SQLite, and presents times in IST. Server operators control announcements and admin grants; an optional CPStats connection adds public-handle lookups. Its offline demo exercises parsing and persistence without contacting Discord. The useful behavior is placing the next contest where the community already talks, rather than building another destination. Its demo runs the real event parser and SQLite cache with synthetic records. Discord, clist.by and optional CPStats access require their own configuration; offline output does not establish those live integrations.

Linked Enigmas And Puzzles gives a Sudoku book a memory. Solve a grid, read selected digits from its completed solution, then carry those values into letter placeholders in the next puzzle. Python generates the chain and assembles printable instructions, indexes, grids and solutions. The generator checks uniqueness and hidden-letter ambiguity, and seeded runs make a particular puzzle set reproducible. The generator uses a solution counter with an early stop once ambiguity is known, then chooses placeholders that preserve the intended link. Page composition includes the link table, instructions, difficulty transitions and solutions. The result is a sequence with a dependency between pages, rather than independent grids placed in one PDF.

An early experiment in treating text and images as different arrangements of bytes. UTF-8 characters become black-and-white pixels, one bit per pixel, in a lossless PNG; reading the grid reverses the transformation. OpenCV and NumPy handle the round trip. There is no secret key or cover image, so this is visible encoding rather than encrypted or hidden communication. The bit grid is a direct transformation of bytes, making the boundary between content and representation visible. Recovering the original text requires a lossless original image: resizing, screenshots or JPEG compression can change pixel values. No key, authentication or secrecy is added by the visual format.

What remains of a picture when it is rebuilt from simple shapes? This Python experiment proposes circles or triangles, mutates their geometry and color, and keeps improvements that reduce pixel error before adding the next shape. Seed, canvas resolution and shape count expose the trade-off between a coarse geometric study and a closer approximation, with optional intermediate images showing the search. Its hill-climbing loop scores the proposed canvas against the target with root-mean-square pixel error. Small working resolutions make iteration cheaper and the geometric effect more obvious; a seed and fixed parameters let a particular experiment be repeated. Coarse and detailed outputs are different trade-offs, not quality claims.

A pygame chess board connects legal-move handling from python-chess with a small inspectable opponent. Share the board with another person or choose among three move strategies, from simple selection to an alpha-beta search with board evaluation. Promotion and restart controls make it playable; the project is an exercise in turning search and rules into a desktop interaction, not a rated engine. The bot module isolates evaluation, move ordering and bounded alpha-beta search from the pygame event loop. That makes the path from legal moves to a chosen action inspectable without a large engine framework. It remains a learning project, with no established Elo, tournament strength or competitive-engine comparison.

Rinse breaks camera-roll cleanup into monthly sessions, one photo at a time. Swipe to keep or mark, undo the latest decision, and reconsider older marks in a persistent local Trash before requesting permanent deletion. React Native/Expo stores review state on-device. The Android preview distinguishes marking from deletion; emulator consent passed, while batch deletion on the tested physical phone remains a documented limitation. Saved sessions and marks use local AsyncStorage, keeping a review resumable without uploading the gallery. Permanent removal is a later Android operation with possible system consent. The documented physical-phone MediaStore failure remains visible alongside the successful emulator check, rather than allowing a preview release to imply universal deletion support.

A scrapbook-style app for a messy group-planning conversation: identify what the messages support, keep unresolved points visible and suggest one question to ask next. A small Node server calls Gemma through Ollama, validates structured output and discards quotations absent from the source chat. The editable result helps a person move the conversation forward without inventing group consensus. The server validates the model’s JSON shape and checks that every retained quote actually appears in the pasted conversation. That grounding does not guarantee the best next question, which stays editable. There is no account, database or saved chat history; local operation is preferable for private messages.

Lol Nope X is a deliberately awkward language-design experiment, with verbose keywords, swapped brackets, improbable booleans, a mandatory Aaron Swartz tribute and “lol nope” errors. The current Python implementation is a lexer that makes those rules concrete. A parser, interpreter and REPL remain planned; the fun is in designing and tokenizing an intentionally hostile language, not claiming a finished compiler. The lexer implements token positions, verbose keywords, number words and intentionally swapped delimiter meanings. Development mode can expose specific errors while the ordinary failure style keeps the joke. Repository documentation marks parser, interpreter, REPL and tests as future work, so the current artifact is a language sketch with tokenization.