Show HN for July 6, 2025

This is a web OS I wrote in vanilla JS that looks like the Apple Lisa Office System (1983-85), with other contemporaneous influences and additional improvements and features. It's currently in alpha and isn't remotely bug free. I had been holding off on posting this here until it was somewhat presentable and useful. Please note; the Lisa conforms more literally to the desktop metaphor than most modern GUIs - some of the important differences are mentioned in the readme.

This is a complete recreation of the UI in JS; it all renders to a single canvas element. It's not a CSS theme, and not an emulator ported to JS. None of the code is written by Apple. I'll be happy to elaborate more in the comments, but the short version is the entire UI is defined outside the DOM using JS objects. Thus, every interface element - menus, windows, controls, and even typefaces - was recreated from scratch. There are no font files - I wrote my own typesetting system, which supports combining multiple text styles and generates new glyph variants on the fly.

Many of the technical decisions I made were motivated by a desire to have this look the same in every browser. That's harder to do with the DOM and CSS, and why I moved as much logic as I could to JS. Also, the only part of the project outside of vanilla JS and standard web APIs is the Gulp toolkit, which I'm using as a minification/build tool. No vibe coding was used to make this!

This is based on a UI from the 80s, and won't work well on your phone. If you insist on running it that way, turn on trackpad mode in the touchscreen settings panel of the preferences app. For best results, install it as a PWA (add it to your home screen). Also there are some odd Android bugs; the native touchscreen keyboard is currently broken, and there's an issue with the cursor when dragging windows.

I realize there's not a whole lot to do within LisaGUI right now; I've got a big list of additional features and apps I'll be adding in the future. I've been working on this project for a while, and I'm eager to hear people's feedback and answer questions about it.

- Enforces sessions even for basic usage

- Requires user-triggered downloads

- Lacks type safety or structured error handling

So I open-sourced a small TypeScript wrapper I originally built for other projects to smooth over the rough edges:

github: https://github.com/kstonekuan/simple-chromium-ai

npm: https://www.npmjs.com/package/simple-chromium-ai

- Stateless prompt() method inspired by Anthropic's SDK

- Built-in error handling and Result-based .Safe.* variants with neverthrow

- Token usage checks

- Simple initialization that provides a helper to trigger downloads (must be triggered by user action)

It’s intentionally minimal for hacking and prototyping. If you need fine-grained control (e.g. streaming, memory control), use the native API directly:

https://developer.chrome.com/docs/ai/prompt-api

Would love to hear what people build with it or any feedback!

I run a small ecommerce shop and, until recently, spent way too many evenings copy-pasting supplier invoices into Excel so my books stayed clean and my expense tracking was granular. It finally hit me that I’d rather invest that time in code than in Ctrl-C/Ctrl-V, so I built ParsePoint.app.

Why I built it • Manual invoice entry was swallowing 4 hours every month. • Accounting software APIs felt heavyweight for my use-case; I really just wanted clean rows in a spreadsheet. • I love tinkering with AI models and needed an excuse to spin one up in production.

What it does 1. Upload a PDF (or forward an email). 2. ParsePoint’s AI OCR extracts line-items, amounts, tax, dates, etc. 3. Download a ready-to-pivot Excel/CSV file or hit the API to drop the data wherever you like.

Under the hood • Frontend: React • API: .NET 8, PostgreSQL • AI layer: an open-source VLLM model fine-tuned for document layouts

Outcome so far • My own workload: from 4 hours/month to less than 10 minutes. • Early beta testers (other solo-store owners) report similar time savings and fewer bookkeeping errors. • The pay-as-you-go credit system means no subscriptions or lock-ins—use it only when you need it.

I’d love feedback on the tech approach, pricing model, or anything that looks off. All comments welcome, and I’m here to answer every question.

Thanks for reading! Marcin – maker of ParsePoint.app

I'd love any feedback on how to make it helpful for you. Thanks.

I was then venting to a buddy about it, and only in that rant, the idea of MoMoney was somehow born — a Duolingo for investing + trading that gamified everything, the same friend I'm actually building with this summer. We then got to some market research and discovered outrageous whitespaces for something like this, and so we started.

We asked users to brutally rate a handful of “what-if” investing scenarios, then used that raw feedback to craft personalized lesson paths — and paired it with a live, game-style trading sandbox that (hopefully) feels more like play than work for the practice anyone sorely needs to get good at trading and/or investing.

TLDR: MoMoney is a “Duolingo-for-investing” app that combines microlearning with a simplified trading simulation so you can learn and practice real-world trading in minutes. We built an MVP to test its reception!

First time posting here on HN, I'd love to hear any thoughts at all

I just released an open-source tool that helps support teams using JIRA to proactively manage ticket SLAs and predict potential breaches before they occur.

It uses Python + AI to analyze historical JIRA data, learn ticket resolution trends, and identify high-risk tickets likely to breach SLA. The tool also includes visualization dashboards and a lightweight classification model trained on real-world support patterns.

Repo: GitHub – SLA Breach Predictor for JIRA

Why I built this: I worked in support engineering and often saw teams overwhelmed with manual tracking and reactive firefighting. This project aims to give them smart, automated foresight without relying on heavy enterprise tools.

Would love feedback, suggestions, or even collaboration! Thanks — Arooj

It's as simple as that:

  * Get your data export from ChatGPT
  * Drag-and-drop the ZIP (or just conversations.json) you download from ChatGPT
  * Parsing happens client-side only, so none of your confidential conversations leave your machine
  * Download each thread individually, or all of them as a ZIP file

I built Pelyos after feeling overwhelmed by long, flat to-do lists that just kept growing. I wanted something timeline-based, simple, and more mindful — not a full-blown team tool or a cluttered app.

I’d love your feedback on what’s working, what’s confusing, and what features would make this more useful for you. I’m currently bootstrapping this solo and hoping to make it truly helpful for knowledge workers, founders, and productivity nerds.

Thanks for checking it out!

So I built LLML - think of it as React for prompts. Just as React is data => UI, LLML is data => prompt.

The Problem:

  # We've all written this...
  prompt = f"Role: {role}\n"  
  prompt += f"Context: {json.dumps(context)}\n"  
  for i, rule in enumerate(rules):  
      prompt += f"{i+1}. {rule}\n"  
  
  # The Solution:  
  from zenbase_llml import llml  
  
  # Compose prompts by composing data
  context = get_user_context()
  prompt = llml({  
      "role": "Senior Engineer",  
      "context": context,
      "rules": ["Never skip tests", "Always review deps"],
      "task": "Deploy the service safely"
  })

  # Output:  
  <role>Senior Engineer</role>  
  <context>  
    ...  
  </context>  
  <rules>  
    <rules-1>Never skip tests</rules-1>  
    <rules-2>Always review deps</rules-2>  
  </rules>  
  <task>Deploy the service safely</task>  

Available in Python and TypeScript:

  pip/poetry/uv/rye install zenbase-llml
  npm/pnpm/yarn/bun install @zenbase/llml

Key features:

  - ≤1 dependencies
  - Extensible formatter system (create custom formatters for your domain objects)
  - 100% test coverage (TypeScript), 92% (Python)
  - Identical output across all language implementations

GitHub: https://github.com/zenbase-ai/llml

Would love to hear if others have faced similar prompt engineering challenges and how you've solved them!