Show stories

Hi everyone,

For the past couple months I've been working on a website with two main features:

- https://book.sv - put in a list of books and get recommendations on what to read next from a model trained on over a billion reviews

- https://book.sv/intersect - put in a list of books and find the users on Goodreads who have read them all (if you don't want to be included in these results, you can opt-out here: https://book.sv/remove-my-data)

Technical info available here: https://book.sv/how-it-works

Note 1: If you only provide one or two books, the model doesn't have a lot to work with and may include a handful of somewhat unrelated popular books in the results. If you want recommendations based on just one book, click the "Similar" button next to the book after adding it to the input book list on the recommendations page.

Note 2: This is uncommon, but if you get an unexpected non-English titled book in the results, it is probably not a mistake and it very likely has an English edition. The "canonical" edition of a book I use for display is whatever one is the most popular, which is usually the English version, but this is not the case for all books, especially those by famous French or Russian authors.

I am excited to announce the release of TabPFN-2.5, our tabular foundation model that now scales to datasets of up to 50,000 samples and 2,000 features - a 5x increase from TabPFN v2, published in the Nature journal earlier this year. TabPFN-2.5 delivers state-of-the-art predictions in one forward pass without hyperparameter tuning across classification and regression tasks.

What’s new in 2.5: TabPFN-2.5 maintains the core approach of v2 - a pretrained transformer trained on more than hundred million synthetic datasets to perform in-context learning and output a predictive distribution for the test data. It natively supports missing values, cateogrical features, text and numerical features is robust to outliers and uninformative features.

The major improvements:

- 5x scale increase: Now handles 50,000 samples × 2,000 features (up from 10,000 × 500 in v2)

- SOTA performance: TabPFN-2.5 outperforms tuned tree-based methods and matches the performance of a complex ensemble (AutoGluon 1.4), that itself includes TabPFN v2, tuned for 4 hours. Tuning the model improves performance, outperforming AutoGluon 1.4 for regression tasks.

- Rebuilt API: New REST interface along with Python SDK with dedicated fit & predict endpoints, making deployment and integration more developer-friendly

- A distillation engine that converts TabPFN-2.5 into a compact MLP or tree ensemble while preserving accuracy and offer low latency inference.

There are still some limitations. The model is designed for datasets up to 50K samples. It can handle larger datasets but that hasn’t been our focus with TabPFN-2.5. The distillation engine is not yet available through the API but only through licenses (though we do show the performance in the model report).

We’re actively working on removing these limitations and intend to release newer models focused on context reasoning, causal inference, graph networks, larger data and time-series. TabPFN-2.5 is available via API and a package on Hugging Face. Would love for you to try it and give us your feedback!

Model report: https://priorlabs.ai/technical-reports/tabpfn-2-5-model-repo...

Package: https://github.com/PriorLabs/TabPFN

Client: https://github.com/PriorLabs/tabpfn-client

Docs: https://docs.priorlabs.ai/quickstart

I have always wanted cool features in Linux because I use it day to day as my OS. I have always wanted to implement this feature and do it properly: one that automatically adjusts keyboard and LCD backlights using data from the Ambient Light Sensor.

I enjoy low-level programming a lot. I delved into writing this program in C. It came out well and worked seamlessly on my device. Currently, it only works for keyboard lights. I designed it in a way that the support for LCD will come in seamlessly in the future.

But, in the real world, people have different kinds of devices. And I made sure to follow the iio implementation on the kernel through sysfs. I would like feedback. :)

I designed a relative piano-roll-based music notation. I used 12 colored arranged in a specific way to make visible the main effects and oppositions of Western tonal harmony. The tonic is always white, so a manual annotation/interpretation is required for each MIDI file.

All chords are flags of three to four colors. Minor mode is darker, major mode is lighter. Colors are arranged in thirds.

I sorted the pieces from simple complex harmony. I also wrote a bit of text to explain what you may see. There's also a corpus of structures: hyperlinks of tags that allow you to find similar patterns throughout my corpus of 3000+ popular pieces.

My method makes chord progressions memorizable and instantly visible in the scores. No preparation of Roman numeral analysis / chord symbols analysis is required. After a bit of training the chords will stare right in your eyes.

It's not synesthesia, it's a missing script for tonal music which makes harmonically identical things look the same (or similar).

I've also recorded lectures on my method in Russian (https://www.youtube.com/playlist?list=PLzQrZe3EemP5pVPYMwBJG...). I'm sorry I haven't yet found time to re-record in English.

I've also sketched a friendlier intro: https://vpavlenko.github.io/d/

Sorry, but this thing won't make any sense if you're color-blind.

It's open-source: https://github.com/vpavlenko/rawl

Earlier context: https://news.ycombinator.com/item?id=39165596

(Back then colors were less logical, and there was no corpus of 3000+ piece annotated yet)

I've been programming since I'm 6 and I don't want to quit. Since Agents came into existence I've been increasingly building more of the random ideas.

BUT, like many I kept getting stuck and frustrated where I wanted to make changes with the Agent that I knew I could've made without it but I had *no clue* how things worked.

I created Intraview to help me build and maintain a mental model of what I was building (or had vibed) so I could use my knowledge to either fix it myself, or provide more directed instruction. It grew into something that's transformed my workflow in a pleasant way.

Intraview is a VS Code extension that allows you to create: - Dynamic code tours built by your existing Agent - Storage and sharing of tours (it's a file) - Batch Feedback/commenting inline in IDE in-tour and without (it's also a file)

Here's a video walkthrough for the show vs tell crowd where I jump in a random (Plotly JS) open source repo and build a tour to get started: https://www.youtube.com/watch?v=ROBvFlG6vtY

Talking tech design, this is very different than most because the whole App is cloudless. Not server less, there's no external APIs (outside basic usage telemetry).

  - basic TypeScript app, JS/CSS/HTML
  - Localhost MCP server inside VS Code (one per workspace open)
 

  - re-considering the user experience given there's no database 
  - trying to build a reasonable experience to manage MCP connection across so many different setups.
  - testing the many forks, Agents and themes because I wanted to make it look native (I'll probably reverse course here in future iterations)

  - New project/developer onboarding 
  - PR reviews 
  - Keeping up with Agentic code 
  - Perf reviews (for EM), you could build a tour biggest contributions by a GitHub handle
  - Planning alignment and review with your Agent

  - for VS Code: https://intraview.ai/install?app=vscode
  - for Cursor: https://intraview.ai/install?app=cursor

  - Create an Intraview the onboarding for this app..
  - Let's use Intraview to gather my feedback on [whatever you created]. Break down steps such that I can provide good granular feedback.

And because this is HN. A relevant quotable from PG.

  “Your code is your understanding 
  of the problem you’re exploring. 
  So it’s only when you have your code 
  in your head that you really understand
   the problem.” 
  
  — Paul Graham

I built qqqa as an open-source project, because I was tired of bouncing between shell, ChatGPT / the browser for rather simple commands. It comes with two binaries: qq and qa.

qq means "quick question" - it is read-only, perfect for the commands I always forget.

qa means "quick agent" - it is qq's sibling that can run things, but only after showing its plan and getting an approval by the user.

It is built entirely around the Unix philosophy of focused tools, stateless by default - pretty much the opposite of what most coding agent are focusing on.

Personally I've had the best experience using Groq + gpt-oss-20b, as it feels almost instant (up to 1k tokens/s according to Groq) - but any OpenAI-compatible API will do.

Curious if the HN crowd finds it useful - and of course, AMA.

Hey HN, I'm Namanyay from https://gigamind.dev/.

One of the most empowering applications of LLMs is enabling non-technical people to build apps and products. This value is reflected in the revenues of companies like Lovable and Bolt. Many of Giga's paying customers are business executives building valuable automations and internal tools that increase efficiency.

But, the incumbents currently operate on pay-as-you-go pricing, which is a predatory business model that I ethically disagree with. I believe the future of vibe coding tool pricing needs to be outcome based vs PAYG. The latter often feels like being held "hostage" over time, when there's vendor lock-in, and especially when the marketing promises are not met.

One step towards that is providing free or low cost inference. The user can continue building till they reach the desired outcome for a longer duration, which is possible if we can somehow make the inference cost negligible. And, the most proven model for offering free stuff online has been ads.

That's why, I've combined the two. I'm offering completely free Claude Sonnet 4.5 for use in Claude Code to empower a new segment to start building with AI.

Launch video (420k+ views): https://twiiit.com/NamanyayG/status/1982939951571591438

How it works:

- We are backed by sponsors. - We inject ads in the responses (a mix of contextual and static). E.g., if you ask about the best AI agentic memory tools, we'll recommend our sponsor https://supermemory.com/ - We store conversations for training or sharing with partners (transparently we are not data sharing right now, but retain the right to do so in the future). - We rate limit dynamically to allow fair usage for all our users. - We are offering the best Claude models for now. Depending on sponsorship, we might have to transition to free or OSS models down the line (e.g. grok-fast-1 or gpt-oss). - Our business actually makes revenue from our premium tool, https://gigamind.dev/context, which creates AI rules file for your project like AGENTS.md automatically.

How to try:

- Register on https://free.gigamind.dev/ - We provide you with an API key and a Claude Code compatible proxy URL. - With a few lines of environment variable changes, you get to use Claude Code, for free. - We'll run out of money if we serve everyone from HN today, so only the first 2⁶ people with coupon code `1337HN` get auto-accepted immediately.

Excited to hear your thoughts!

This is a DIY, open-source alternative to expensive solutions like the MouthPad, eye-trackers, or even complex systems like Neuralink. Everyone deserves access to assistive technology.

I tagged all comments from "What Are You Working On?" (like https://news.ycombinator.com/item?id=45561428) posts and built a simple SvelteKit website, hope it's helpful to find people with similar projects. I'm also thinking of adding some analysis of project types over time to see changes in tech

ShellAI is an open-source project that aims to bring artificial intelligence capabilities to the command line interface, allowing users to execute AI-powered commands and access various AI-driven functionalities from within their terminal.

Terra is a user-friendly, open-source platform that enables the rapid design and deployment of decentralized applications (dApps) on the blockchain. It provides a comprehensive suite of tools and frameworks to simplify the development process, making blockchain technology more accessible to developers of all skill levels.

The article discusses the fx library, a Rust-based financial modeling and data analysis tool that provides a flexible and efficient way to perform various financial calculations, including time value of money, bond analytics, and option pricing.

Mint MVP is a comprehensive platform that provides user-friendly tools, resources, and community support for entrepreneurs and small business owners to create, launch, and grow their ventures. The article highlights Mint MVP's diverse offerings, including business planning templates, marketing strategies, and access to a network of experienced mentors.

A while ago I wanted to write some tools to process EPUBs in JavaScript, the format is basically zipped XML so I immediately looked for a parser. There are quite a few XML parsers for JavaScript but I was disappointed to find out that basically none of them support the full XML specification, namespace support was not very good and they were quite slow for what they did.

None of the parsers I saw around support proper entity expansion or check the internal DTD for syntax errors. This approximation is not benign, if the XML data processed is passed to other software it could be interpreted differently.

And that's the story of why I made my own.

Though not definitive, I also ran some benchmarks against other libraries:

https://github.com/federicocarboni/saxe/tree/trunk/bench

Data Formulator 0.5 released! It's a new research prototype from Data Formulator team @ Microsoft Research.

It's quite a leap since our first prototype last year -- we bring agent mode to interact with data, together with an online demo that you can play with (https://data-formulator.ai/).

"Vibe with your data, in control" -- featuring agent mode + interactive control to play with data, it should be more fun than last time you discovered it!

- Load whatever data - structured data, database connections, or extract from screenshots/messy text - Flexible AI exploration - full agent mode OR hybrid UI+NL control for precision - Data threads - branch, backtrack, and manage multiple exploration paths - Interpretable results - inspect charts, formulas, explanations, and generated code - Report generation - AI creates shareable insights grounded in your data

* Online demo at: https://data-formulator.ai/ * Github: https://github.com/microsoft/data-formulator * new video: https://www.youtube.com/watch?v=GfTE2FLyMrs * take a look at our product hunt page: https://www.producthunt.com/products/data-formulator

It's a Mac desktop app that lets you iterate on storyboard, generate Sora videos, and edit them (stitching, trimming, transitions) to produce a long AI-generated video.

It's MIT license and BYOK.

We've found some fun use cases with Sora that are not brain-rot meme videos on the Sora app, for example: - Turning blog posts to video

- Making launch videos

- Making educational videos

- (currently experimenting) Marketing Ads

But we don't want to pay $200 for the max plan, so instead we built this to use our existing API credits. With this app, you have access to:

1. storyboard with a AI chat 2. watermark-free videos 3. sora-2-pro 4. basic editing with ffmpeg

Would love to hear some feedback. Hope you find it useful and fun too!

Download link (Apple Silicon): https://github.com/palmier-io/sixsevenstudio/releases/downlo...

I’ve been experimenting with Rust lately and wanted a project that would help me explore some of its lower-level and performance-oriented features. Inspired by Sebastian Lague’s videos, I decided to implement my own ray tracer from scratch.

The initial goal was just to render a simple 3D scene in the browser at a reasonable frame rate. It evolved into a small renderer that can: • Run locally or on the web using wgpu and WebAssembly • Perform mesh rendering with a Bounding Volume Hierarchy (BVH) for acceleration • Simulate both direct and indirect illumination for photorealistic results • Be deployed easily as a free web demo using GitHub Pages

The project is far from perfect, but it’s been a fun way to dig deeper into graphics programming and learn more about Rust’s ecosystem. I’m also planning to experiment with Rust for some ML projects next.

GitHub: https://github.com/tchauffi/rust-rasterizer Web demo (desktop browsers): https://tchauffi.github.io/rust-rasterizer/

Would love feedback from anyone who’s built similar projects or has experience with wgpu or ray tracing in Rust.

I went down the rabbit hole on a side project and ended up building this: Strange Attractors(https://blog.shashanktomar.com/posts/strange-attractors). It’s built with three.js.

Working on it reminded me of the little "maths for fun" exercises I used to do while learning programming in early days. Just trying things out, getting fascinated and geeky, and being surprised by the results. I spent way too much time on this, but it was extreme fun.

My favorite part: someone pointed me to the Simone Attractor on Threads. It is a 2D attractor and I asked GPT to extrapolate it to 3D, not sure if it’s mathematically correct, but it’s the coolest by far. I have left all the params configurable, so give it a try. I called it Simone (Maybe).

If you like math-art experiments, check it out. Would love feedback, especially from folks who know more about the math side.

To play go here ssh web2u.org -p6996

The Rules:

The goal is to claim the most space

Secondary goal is to kill as many other Ourboroses as you can The how:

To claim space you need to either eat your own tail or reach tiles you've already claimed, tiles that are enclosed when you do so become yours!

To kill other snakes you hit their tails To watch out:

Other players can kill you by hitting your exposed tail

Other players can take your tiles.

Hello,

For quite some time, I've been unsatisfied with the built-in timers on both Android and iOS; especially for workouts, when I needed to set up a configurable number of series with rest periods in between. That's when I started thinking about building something myself. It was just a timer and I said to myself "how hard could it be?", I had no idea.

The first iteration of the project worked "just fine", but the UI was an eyesore (even more than it is now), and the UX was quite awful as well. As you can probably guess, I'm not versed in design or front-end development. In fact, my last real experience with front-end work was back when jQuery was still a thing.

However, I knew what I wanted to build, and over the last few days (and with the help of the infamous AI) I was able to wrap up the project for my needs. It required quite a lot of "hand holding" and "back and forth", but it helped me smooth out the rough edges and provided great suggestions about the latest ES6 features.

The project is, as the title states, an offline-first PWA with zero dependencies; no build step, no cookies, no links, no analytics, nothing other than timers. It uses `Web Components` (a really nice feature, in my opinion, though I still don't get why we can't easily inherit styles from the global scope) and `localStorage` to save timers between uses.

I'd appreciate any comments or suggestions, since I just want to keep learning new things.

https://mytimers.app/

I've been working on a more efficient approach to code execution with MCP servers that eliminates the filesystem overhead described in Anthropic's recent blog post.

The Anthropic post (https://www.anthropic.com/engineering/code-execution-mcp) showed how agents can avoid token bloat by writing code to call MCP tools instead of using direct tool calls.

Their approach generates TypeScript files for each tool to enable progressive discovery. It works well but introduces complexity: you need to generate files for every tool, manage complex type schemas, rebuild when tools update, and handle version conflicts. At scale, 1000 MCP tools means maintaining 1000 generated files.

I built codex-mcp using pure dynamic execution. Instead of generating files, we expose just two lightweight tools: list_mcp_tools() returns available tool names, and get_mcp_tool_details(name) loads definitions on demand. The agent explores tools as if navigating a filesystem, but nothing actually exists on disk.

Code snippets are stored in-memory as strings in the chat session data. When you execute a snippet, we inject a callMCPTool function directly into the execution environment using AsyncFunction constructor. No imports, no filesystem dependencies, just runtime injection. The function calls mcpManager.tools directly, so you're always hitting the live MCP connection.

This means tools are perpetually in sync. When a tool's schema changes on the server, you're already calling the updated version. No regeneration, no build step, no version mismatches. The agent gets all the same benefits of the filesystem approach (progressive discovery, context efficiency, complex control flow, privacy preservation) without any of the maintenance overhead.

One caveat: the MCP protocol doesn't enforce output schemas, so chaining tool calls requires defensive parsing since the model can't predict output structure. This affects all MCP implementations though, not specific to our approach.

The dynamic execution is made possible by Vercel AI SDK's MCP support, which provides the runtime infrastructure to call MCP tools directly from code.

Project: https://github.com/pranftw/aiter-app

Would love feedback from folks working with MCP at scale. Has anyone else explored similar patterns?

I had a hard time figuring out CAD software like Fusion, OnShape, etc., and decided to go about making my own CAD modeling software that I can "program" my models similar to how I think about them in my head.

I used Cursor to write like 95+% of this, giving it my YAML examples and making it implement the actual code to make those work.

Currently 100% self-hosted, and it is just a static HTML/CSS/JS, so it might just work without running npm at all.

Very few features working currently, basically just modeling a few primitive solids, and boolean operations.

Hi, I'm Andrew Trettel. I'm a scientist and researcher. I wrote Wosp to help me search local documents using Boolean and proximity operators.

Wosp is a command-line program that performs full-text search on text documents. Wosp stands for word-oriented search and print. It is designed for advanced searchers. It works differently than line-oriented search tools like grep, so it can search for matches spanning multiple lines. Wosp supports an expressive query language that contains both Boolean and proximity operators. It also supports nested queries, truncation, wildcard characters, and fuzzy searching.

The linked GitHub repository contains all of the code to try out the program. I also wrote a blog post (https://www.andrewtrettel.com/blog/wosp/) that discusses my motivations for creating Wosp in more detail, along with some additional technical discussion and diagrams.

If you give Wosp a try, I'd appreciate any comments or feedback you have about the experience.

We built a local-first, private, multi-currency, double-entry based personal finance app. It will help you track, visualize, and plan your financial journey. Use the `Try demo` button, to try it without an account. Small screens (mobiles) are not supported yet.

By local-first we mean, your data is on your system (we use sqlite over opfs, in browser). For synching across devices, the data is encrypted with your key before it leaves your device. You can backup the data locally (if you are using chrome) and/or to your dropbox. It's designed so that we (the people building it) can't access your data.

Why double-entry? Many personal finance apps operate on single entry model. But it quickly reaches limits with complicated set of transactions (returns on a house, your networth and a lot more). FinBodhi uses double entry so complicated set of transactions and accounts can be modeled (which happen often enough in users financial journey). We wrote about double-entry here: https://finbodhi.com/docs/understanding-double-entry

FinBodhi currently supports import, tracking, visualization and planning. There are few built in importers and you can define your own custom importer, apply rules to imports etc. You can slice and dice your transactions, split/merge transactions, associate them with accounts etc. We support cash and non-cache accounts. For non-cache mutual fund and stock accounts in Indian context, we can fetch price for you. For others, there is manual price entry. We also support multi-currency, and you can set price for currency conversions also. You can view reports like Balance Sheet, Cashflow, P&L and much more, and visualize data in various ways. And when you are ready, start planning for your future.

Eventually we would like the app to cover a users complete financial journey. There is a lot more that can be done (like mobile support, budgeting, price fetching, improved imports, ai integration and a lot more), but the current set of features is quite usable. We have written down our manifesto, which guides the overall development: https://finbodhi.com/docs/manifesto/

Please give it a try. All plans are free for now. Reach out to us at discord: https://discord.gg/mQx649P6cy

I spent a few hours last weekend testing whether AI can replace code by executing directly. Built a contact manager where every HTTP request goes to an LLM with three tools: database (SQLite), webResponse (HTML/JSON/JS), and updateMemory (feedback). No routes, no controllers, no business logic. The AI designs schemas on first request, generates UIs from paths alone, and evolves based on natural language feedback. It works—forms submit, data persists, APIs return JSON—but it's catastrophically slow (30-60s per request), absurdly expensive ($0.05/request), and has zero UI consistency between requests. The capability exists; performance is the problem. When inference gets 10x faster, maybe the question shifts from "how do we generate better code?" to "why generate code at all?"

The article discusses the development of Anki-LLM, an open-source project that integrates large language models (LLMs) into the Anki flashcard system, enabling users to leverage the knowledge and capabilities of these models for more effective learning and study.

Hi HN, I'm the author of Kumi, a declarative, statically-typed, array-oriented, compiled DSL for building calculation systems (think spreadsheets). It is implemented entirely in Ruby (3.1+) and statically checks everything, targets an array-first IR, and compiles down to Ruby/JS. I have been working on it for the past few months and I am curious what you think.

The linked demo covers finance scenarios, tax calculators, Conway's Game of Life (array ops), and a quick Monte Carlo walkthrough so you can see the zero-runtime codegen in practice. (The GOL rendering lives in the supporting React app; Kumi handles the grid math.)

The Original Problem:

The original idea for Kumi came from a complex IAM problem I faced at a previous job. Provisioning a single employee meant applying dozens of interdependent rules (based on role, location, etc.) for every target system. The problem was deeper: even the data abstractions were rule-based. For instance, 'roles' for one system might just be a specific interpretation of Active Directory groups and are mapped to another system by some function over its attributes.

This logic was also highly volatile; writing the rules down became a discovery process, and admins needed to change them live. This was all on top of the underlying challenge of synchronizing data between systems. My solution back then was to handle some of this logic in a component called "Blueprints" that interpreted declarative rules and exposed this logic to other workflows.

The Evolution:

That "Blueprints" component stuck in my mind. About a year later, I decided to tackle the problem more fundamentally with Kumi. My first attempts were brittle—first runtime lambdas, then a series of interpreters. I knew what an AST was, but had to discover concepts like compilers, IRs, and formal type/shape representation. Each iteration revealed deeper problems.

The core issue was my AST representation wasn't expressive enough, forcing me into unverifiable 'runtime magic'. I realized the solution was to iteratively build a more expressive intermediate representation (IR). This wasn't a single step: I spent two months building and throwing away ~5 different IRs, tens of thousands of lines of code. That painful process is what forced me to learn what it truly meant to compile, represent complex shapes, normalize the dataflow, and verify logic. This journey is what led to static type-checking as a necessary outcome, not just an initial goal.

This was coupled with the core challenge: business logic is often about complex, nested, and ragged data (arrays, order items, etc.). If the DSL couldn't natively handle loops over this data, it was pointless. This required an IR expressive enough for optimizations like inlining and loop fusion, which are notoriously hard to reason about with vectorized data.

You can try a web-based demo here: https://kumi-play-web.fly.dev/?example=monte-carlo-simulatio...

And the repo is here: https://github.com/amuta/kumi

I recently got fired and decided to channel my energy into something productive. Over two weeks, I spent 16-hour days building a tool that converts Australian bank PDFs into clean, reliable CSVs, tailored specifically for Aussie banks.

Most Aussie banks only provide statements as a PDF, and generic converters often fail: columns drift, multi-line descriptions break parsing, headers shift. Existing tools don’t handle it well and I wanted a tool that just works.

To get started, I used my own bank statements to build the initial parsers. There was a "duh" moment when I realised how hard it is to get more realistic test data. People don't just hand over their financial ledgers. This solidified my core principle: trust and privacy had to be the absolute top priority.

I initially tried building everything client-side in JavaScript for maximum privacy, but performance and reliability were poor, and exposing the parsers on the front-end would have made them easy to copy.

I settled on a middle ground: a Python and FastAPI backend on Google Cloud Run. This lets me balance reliability with a strict privacy architecture. Files are processed in real-time and the temp file is deleted immediately after the request is complete. There is no persistent storage and no logging of request bodies.

My technical approach is straightforward and focused on reliability:

- I use pdfplumber to extract text, avoiding complex and error-prone OCR.

- I apply a set of bank-specific regex patterns to pinpoint dates, amounts, and descriptions.

- A lookahead heuristic correctly merges multi-line transactions. Each parser is customised to its bank's unique PDF layout quirks.

The project is deliberately focused. Instead of supporting hundreds of banks with mediocre results, I'm concentrating on a small set to get them right. It currently supports CommBank, Westpac, UBank, and ING, with ANZ and NAB next. The whole thing is deployed on Cloudflare Pages and outputs clean CSVs ready for Excel, Google Sheets, Xero, or MYOB.

It was a fun challenge in reverse-engineering messy, real-world data.

Try it out here: https://aussiebankstatements.com

I'd love to hear feedback. If it breaks on your statement, a redacted sample would be a huge help for improving the parser.

I'm also curious to hear how others here have tackled similar messy data extraction challenges.

The To-Do List Planner Zesfy app offers users a comprehensive task management solution, allowing them to create, organize, and track their daily tasks and activities.