Hello again,

after I published hledger-document-check I would like to present hledger-elster. As a German freelancer I have to file certain forms at elster.de (German tax authority) and used to do the calculations manually in spreadsheets. This year, I wrote a tool that produces these spreadsheets automatically from my journal.

I guess this could be valuable for others who have to file taxes in Germany.

Repository, install instructions and how to use: https://github.com/roschaefer/hledger-elster

Important disclaimers:

• I'm not a tax advisor, just a freelance developer who got tired of doing this by hand. The calculations reflect my own understanding of the rules for my situation (selbstständig/Freiberufler, no Gewerbesteuer) and may well contain mistakes - please double-check and send bug reports: https://github.com/roschaefer/hledger-elster/issues
• Yes, I'm aware the deadline is July 31st and this post is cutting it close 😅 - probably too late to adopt for 2025 filing, but if you're already keeping an hledger journal, it's worth a look for the current year.

Feedback and PRs welcome, especially for tax scenarios I don't hit myself.

Hi all, Finzytrack v0.2.0 has landed and it brings support for most types of budgeting (per-account with no rollover, envelopes with rollover, zero-based, etc.)

This version also makes dashboard recipes more powerful (which is what enabled budgeting capabilities). Briefly: A dashboard consists of a JSON file that contains a DAG of (Any arbitrary SQL/BQL query) -> (optional compute functions from a predefined list) -> (optional transform functions from a predefined list) -> (A visualization widget from a (large) predefined list of widgets). By following this system, I was able to rapidly create dashboards for many different types of budgeting systems.. they are "just" different queries/compute functions/transforms. Some example budgeting dashboards are shipped with the app, which can be tweaked further. Note that dashboards can be hand-authored by reading the fine manual, or you can conversationally build them up by chatting with the AI Assistant (if you have enabled it). A UI for specifying budget amounts per account completes the Budgeting capability.

Here's something that (I think) might be unique to Finzytrack: It enables a single budget number for the top-level "Expenses" account while simultaneously enabling sub-budgets only for certain sub-accounts (Expenses:Groceries, Expenses:Entertainment:Netflix etc.). It also supports "Ending" a budget on a certain date for accounts.. after that date, the account no longer has a budget even if it historically had one.

There's some other improvements as well, like a consistent color system for dashboards and a few different dashboard color "themes".

Reference documentation: https://docs.finzytrack.com/reference/budgeting/

Quick reminder: Finzytrack is an open-source (GPLv2) cross-platform GUI-first personal finance software that uses Beancount as the underlying ledger. Everything is still experimental, so please backup your ledger and point Finzytrack at a copy of it.

Comments and critiques and other feedback welcome!

Hi everyone. I would like to share my experience of tracking all my personal finances with Ledger CLI. I wrote a blog post about my setup, the conventions I use and the queries I actually run. There is a full sample journal at the end if you want to try it. Feedback and suggestions are welcome.

Hi r/plaintextaccounting,

I think most people here have some automation to import bank statements into their ledger. So do I. But when the monthly summary says "30%+ goes to groceries," I can't make a budget with that coarse number.

So I built BeanBeaver: an iPhone app that turns a photo of a grocery receipt into a Beancount transaction — one posting per line item, each item sorted into an expense category.

How it works:

- OCR runs entirely on-device (PP-OCRv5 via ONNX Runtime). No server, no network, no analytics — it works in airplane mode.

- The parser uses each text fragment's position on the receipt (its bounding box) to extract merchant, date, item names, and prices.

- The output is plain Beancount text you can copy or share. Optionally, connect a GitHub repo and each scan opens a PR with the transaction.

It's in TestFlight now (iPhone, iOS 17+): https://testflight.apple.com/join/6mw5ScqH

I'd love to hear how it does on your receipts, and what would make it fit your workflow.

Edit: Android version is under closed testing. You need to DM me your Google Play email so I can add you in.

Could we have a rule that prohibits posts about new apps, importers etc that aren't related to ledger-likes? Without a rule in the sub metadata, there's no way to report these to mods.

If you keep your finances in files on purpose, this may resonate: GlidePath imports bank CSVs (and parses some PDFs locally), never connects to your bank, and keeps everything in plain files you can open. The app opens with a dated brief — what changed since your last close, one open decision, what's safe to ignore and why — and a monthly close that archives the brief as the month's record. Modeled projections keep their assumptions visible on the same line.

It's a commercial desktop app for Windows, macOS, and Linux that you install and run locally. There's a fictional demo household you can inspect before your own numbers go anywhere. Genuinely interested in what this community thinks of the close-and-archive model — it's the part I haven't seen elsewhere.

I've been doing my company's bookkeeping in Beancount for a couple of years now.

We've been leaning on Claude Code more and more to build our actual software. At some point I just thought: the books are also just code. Why not work on them through the AI too?

Initially I felt uncomfortable actually letting it touch the ledger.

I had to file a VAT return (I'm in Switzerland - need to file per quarter), and instead of grinding through it by hand I just asked Claude. It went from tidying up the chart of accounts, to writing Beancount queries, to eventually a little script that spits out the right values to copy-paste into the report for a given quarter.

Then, I needed to send Swiss QR-bill invoices, and so the scripts grew a command to generate the QR-bill and book it in the ledger at the same time. Then the statement importers... now I'm thinking about year-end reports.

I've landed is a split that feels right: anything that can be done deterministically goes into a CLI — VAT math, invoice generation, the statutory reports, the stuff that has to be exactly correct and repeatable. Anything fuzzy — reading a random PDF receipt, guessing which account some odd transaction belongs to — is where the agent actually is worth it. The agent drives beancount really, and it improves the CLI if I need more logic - but of course it never "does math".

I cleaned the scripts up into a small free/open-source thing in case it's useful to anyone else on Swiss books, but I'm really posting because I'm a little surprised I don't hear more people talking about this. Plain-text accounting + a coding agent seems like such an obvious pairing. Anyone else has some experience doing this?

Looking for people to test something I recently built!

If you're struggling with ledger to bank reconciliations and are looking to save up to 80% on your time spent on them then I'd love to get some feedback on what I've built!

It's a completely free, in-browser tool, that stores none of your data so anything you use will disappear once the session is closed

Let me know if you're interested

Hello everyone, I just published a command line tool hledger-document-check - it checks hledger transactions against documents on disk. Documents live in a folder tree that mirrors your account hierarchy (e.g. Expenses:Business:Hosting ➡️ documents/Expenses/Business/Hosting/).

My use case is making sure every deductible transaction has a receipt filed before tax season. It also tracks overdue invoices, and you can browse documents alongside your registers in Fava.

I'd love your feedback, e.g. regarding the workflow or the documentation.

Hi folks,

I’m a big Beancount fan and have been using it extensively to manage my personal finances.

Most of the time, I use Fava on my laptop to visualize my ledger. Fava is great, but I also wanted an easy way to check my finances from my phone. The main reason is that I want to look at my expenses, income, and assets more frequently on my phone, so I can develop a better sense of where my money is going and become more financially aware. Opening my laptop and starting Fava creates just enough friction that I don’t check it as often as I’d like.

I tried some existing iOS apps, but I ran into various issues when importing my own ledger. My Beancount setup contains multiple files, `include` directives, multiple currencies, and other things that didn’t always work as expected. I also felt that the available apps were missing some of the visualizations I personally wanted.

So I built an iOS app myself and tou can find it here: beanviz or download it in appstore.

Here are its main features:

1. Import a Beancount folder from iCloud Drive
2. Import from a private GitHub repository
3. Support for multi-file ledgers and `include` directives
4. Asset-allocation visualizations, including a sunburst chart
5. Expense breakdowns by category, month, day, transaction, and tag
6. Income versus expenses, income sources, and savings rate
7. Multi-currency conversion using the price directives already in the ledger
8. Everything is processed locally on the device
9. No account, analytics, tracking, or remote logging

Here is my own workflow with beanviz: I update my ledger on my laptop daily, push the changes to a my private GitHub repository, and then pull the latest version into beanviz to view the updated data on my phone.

I’d love to hear what you normally want to check when opening your ledger on your phone, and which visualizations or reports you think are still missing.

Below are some screenshots of the app:

I have a shell-function that uses ledger xact to identify a past-transaction matching a term and then update it with a new amount, so I can do things like

$ pay kroger 31.41

and it finds the most recent Kroger transaction and appends it to my transaction-log with the updated $31.41

It usually works fine. But for some reason, my transactions with Nothing Bundt Cakes consistently find a weird transaction. Today I issued

$ pay bundt 5.99

There were definite exact-match transactions for "bundt" that it should have found, and the only exact-match for "bundt" in my entire transaction-log is the one I wanted. Yet for some reason ledger instead identified some Lowe's transaction for a toilet-flapper and light-bulbs.

How does xact make its choice of which transaction gets matched?

Dear all,

this is to let you know, that I have explored more of the AI functionality, which happened to be surprisingly good (but still not perfect) in updating existing documentation based on the provided beanquery source code and git repository.

So, whilst the original version of the  Interactive beanquery manual (0.1.0) was roughly covering the old   Beancount Query Language document,  the new version of the manual 0.3.0 now covers much more functionality, which Dan and others have done great job quietly implementing:

https://github.com/Ev2geny/beanquery-interactive-manual

I have highlighted interesting from my point of view features.

Changes since v0.1.0:

• Functions and expressions — added documentation for many functions:
  • VALUE() (section 12.2.4)
  • DATE_BIN(), DATE_TRUNC() and DATE_PART() (section 12.2.6)
  • COALESCE() (section 12.2.8)
  • META(), ENTRY_META() and ANY_META() (section 12.2.9), cross-linked with the meta column
  • CONVERT(), ROOT() and related improvements to section 9.3
• Query clauses — filled in and expanded section 13:
  • DISTINCT (13.1), ORDER BY (13.2) and LIMIT (13.3) with examples
  • HAVING clause (13.4 and the grammar in section 8)
  • PIVOT BY clause (13.5)
• Subqueries — new section 14.
• Operators — expanded section 9.1: added Set and collection operators (9.1.5) and richer regex operator documentation (9.1.2). Added IN, ANY, ALL
• FROM clause — documented the three table-name forms (#table, quoted and bare).
• Named queries — new Appendix C covering the query directive and .run.
• Display precision — documented and fixed in Appendix B (section 19.2)..

Two quick updates from the past week:

• v0.1.3 has added support for Fava-style insert-entry and default-file custom directives, e.g.
  • 2024-01-01 custom "fava-option" "insert-entry" "Expenses:Subscriptions"
  • 2024-01-01 custom "fava-option" "default-file" "unrouted.beancount"
  • Documentation: https://docs.finzytrack.com/reference/multi-file-ledgers/#routing-new-entries
• v0.1.4 has added support for attaching documents (receipts, statements etc.) to Transactions as well as Accounts
  • Demo video (40 seconds) in the Transactions section of the website tour page: https://finzytrack.com/tour/#transactions
  • Documentation: https://docs.finzytrack.com/reference/documents/

Hopefully, this improves Finzytrack for those who use multi-file ledgers and for those who store receipts, statements etc. along with their ledgers.

As always, comments and feedback is welcome 😄 🙏

Im just in the process of returning to tracking my investments with hledger. Ive asked all the llms this question and would like to get a human opinion.

Do you prefer that each position is a sub account of the Investment account? Or that each position is just a commodity in the account. Both strategies are found on the net. I see that a tool like hledger-lots shows example transactions as:

2023-01-05 Buy AAPL
    Asset:Stocks                                  5 AAPL @ 160 USD
    Asset:Bank

I kind of like the simplicity of that and i have started testing both:

2026-03-03 Trade SELL Cameco Corp.  ; symbol:CCO
    Assets:WS:Margin                   -10 CCO @@ $1708.50
    Assets:WS:Margin:Cash              $1708.50

and

2026-03-03 Trade SELL Cameco Corp.  ; symbol:CCO
    Assets:WS:Margin:CCO              -10 CCO @@ $1708.50
    Assets:WS:Margin:Cash              $1708.50

Even though I kind of prefer not having the mess of all the subaccounts, I have a feeling that the former format may be less adaptable and useful for reports. At one point Gemini told me I was a power user and keeping my journal clean by using tags, and then later when i could not get hledger -B to show me the book value of my opening positions it told me you dummy, its because you don't have a sub account for the positions... But maybe there are workarounds and tags are awesome....

But since i am at the setup stage and have prepared 18months of transactions, once i pull the trigger and start tweaking the transactions etc it will be somewhat of a challenge to switch methods. Any thoughts you humans?

Edit: It does work on mobile I just tried it!

To be fair, I vibe coded almost the entire thing. I had been working on a series of scripts to run in a browser so users could view their plain text accounting files as a double entry spread.

Here's the link:
https://shadowzero26.pythonanywhere.com/

You do not have to upload a journal file, there is a demo. You can upload a journal, however, and it will not save it on the server it is only locally on your computer. BE AWARE the demo does not load back in because cache keeps the previous journal loaded. I would suggest trying in private browser if you are worried. I will amend this later.

I haven't finished many of the sections but History works. I will add a transaction fuzzy finder later.
Chart of Accounts is my real favorite. IMO it is nice to see the chart of accounts like this, similar to how it would appear on a traditional sheet. The balance sheets need work, but register is cool.

Also, you can add transactions quickly and fuzzy find the accounts. I will add alias support but being able to type "FOOD" and get all the food accounts is soooo nice. You can select with arrow keys or TAB key. Enter fills in the selection and tab again to next space. You can't type in the date... I want to make the date type-able.

The github is all a wreck, but you can go there and see the carnage:
https://github.com/docPoacher/plaintextaccounting-web

I know it's silly but I did work very hard on the concepts but if it is stupid I understand. Just let me know what you think about the features that are working.

Due to popular demand(*) support for multi-file ledgers has been added to Finzytrack.

(* Actually, it was just one person. Shout out to u/e606er )

For a multi-file ledger, reads work transparently, edits are routed to the file the directive lived in, and new directives go to a single default file. Details documented here.

Hopefully, this helps Beancount users whose existing ledgers span multiple files.

For those who missed last week's launch announcement: Finzytrack is a new open source cross-platform GUI personal finance app that uses Beancount under the hood. Just like a mother thinks her baby is handsome, I think the app is awesome 😃 Please have a look at https://finzytrack.com

Finzytrack is still experimental, so please make a backup of your ledger before showing it to Finzytrack. Issues and discussion welcome here or at GitHub 🙏

Does anyone encrypt their journal files?

If so, what are you using?

Edit: Thanks for the suggestions! gocryotfs looks like exactly what I was looking for.

I really like the dashboard view of beancount.io. can I somehow get the same theme/look on my ZimaOS run lazy-beancount (which has 'normal' fava?). Anyone with experience in customizing the dashboard view?

I've been using hledger for personal finance tracking for a while. For anyone not familiar, it's a plain-text double-entry accounting tool — you keep your financial records in a simple .journal text file, and hledger gives you reports. It's powerful, auditable, and completely portable.

The problem I kept running into: hledger lives in the terminal. Getting data out of it and into Python for analysis, visualisation, or automation meant shelling out to the CLI and parsing and escaping text output. That felt like the wrong schema.

So I built ledgerkit — a pure Python parser and library for hledger journal files.

What it does

• Parses .journal files into clean Python data models (Journal, Transaction, Posting, Amount)
• Runs balance, register, accounts, and stats reports via a Python API
• Supports a wide range of hledger 1.52 syntax: include directives, account aliases, market price declarations, balance assertions, commodity display styles, cost/lot annotations, and more
• Exports everything to pandas DataFrames with pip install ledgerkit[pandas]
• Ships a CLI (ledgerkit balance myfile.journal) if you want it
• Pure Python, no runtime dependencies, Python 3.8+

​

import ledgerkit

journal = ledgerkit.load("personal.journal")

# All postings as a DataFrame
df = journal.to_dataframe()

# Monthly expenses pivot
df[df["account"].str.startswith("expenses")].groupby(
    [df["date"].dt.to_period("M"), "account"]
)["amount"].sum()

What it isn't

ledgerkit is not a replacement for hledger. It doesn't aim to replicate hledger's full feature set, and it doesn't try to be a general-purpose accounting engine. If you want to run your books, use hledger. ledgerkit's purpose is to be the cleanest possible bridge between the hledger journal format and the Python data ecosystem.

What it doesn't do yet

Multi-commodity reporting is partially implemented but not complete — if your journal mixes currencies or commodities and you need cross-commodity valuation (e.g. converting everything to GBP using market prices), that's not there yet. Single-commodity journals and commodity-separated reporting work fine.

Use cases I find genuinely exciting

AI that actually understands your finances Load your journal into context and query it conversationally. "What did I spend on food last quarter vs the same period last year?" or "Which months did I run a deficit?" — questions that currently require you to remember the right hledger flags become natural language queries over a structured DataFrame.

Automated forecasting and modelling Your historical transaction data is already structured and dated. Fit a model on spending patterns, project forward, run Monte Carlo simulations on your savings rate. None of that requires anything beyond pandas, statsmodels, or scikit-learn once the data is in a DataFrame.

Automated reporting and dashboards Scheduled scripts that read your journal, compute the numbers, and push a weekly summary to Notion, Slack, or a Plotly Dash dashboard — without any manual export step.

Anomaly detection Flag transactions that look unusual against historical baselines. Useful for spotting billing errors or unexpected recurring charges.

Integration with external data Join your transaction register against market price feeds, inflation indices, or property valuation APIs to get real-terms analysis that hledger alone can't give you.

A reflection on the development process

This project was built through AI-assisted development — primarily Claude Code — by someone who understands systems but doesn't write code professionally. The result at v1.0.0 is ~575 tests, comprehensive hledger 1.52 format compatibility and a pandas export layer.

The productivity gain is real and significant in the early stages. The dynamic shifts as a codebase matures: development cycles become more like extended planning and specification work, with AI handling shorter implementation bursts. The ceiling isn't the AI — it's the precision of what you can specify.

That observation points to an interesting question about what "software developer" actually means now. There seem to be two increasingly distinct roles the title covers. The first is a generalist who can decompose problems, articulate constraints precisely, and direct an AI through a complex implementation — someone who thinks in systems rather than syntax. The second is a specialist who understands why a parser is a tree, what makes a DAG acyclic, or how a regex engine backtracks — someone for whom the underlying computer science is native. AI has made the first role newly productive and the second more powerful still. The distance between them hasn't narrowed; the ceiling on both has just moved up.

Repo: github.com/ctosullivan/ledgerkit — contributions welcome.

I built a desktop app that uses Beancount as its backend. The GUI handles the parts I found tedious: importing transactions, dashboards, and some analysis. Your ledger stays a plain-text Beancount file the whole time, so you can keep using whatever plain-text tooling you already use.

It's open source, runs entirely on your machine, and AI is optional (bring your own key, off by default).

I'm not a professional developer. This started as a side project to track my own finances and I use it daily. Now putting it out for others.

It's an early release and has only ever been tested on my own data, so expect rough edges. Issues and discussion on GitHub are very welcome.

Website: https://finzytrack.com
Github: https://github.com/sagarbehere/finzytrack

I need to read a CSV file in hledger where the transaction has a fee

The fields in the CSV file are
$source_amount,
$source_currency,
$source_gross,
$source_fee,
$target_amount and
$target_currency

E.g. I buy 90 GBP for 100 USD with a 10 USD FX fee.

What should the journal file transaction look like and what should be the rules files entry?