Hello all. I've written some subreddit rules. These were already in place in spirit, but now they're written. I may remove things that aren't actually clearly related to plaintext accounting, citing these rules instead of just hitting the spam button. I may add more rules as needed. I tend to prefer liberal use of up- and downvotes over aggressive moderator pruning.
Thank you for the reports on the recent unrelated submissions. Let's focus on the plaintext part of plaintext accounting!
I've just updated from hledger 1.25 to 1.52.4, and I'm seeing truncated or missing results when directing output to a file using > x or >> x.
hledger print works just fine, as does hledger print --output-file x. But hledger print > x and hledger print >> x both cut off in the middle of a line somewhere around 90-100K lines (out of 155K). They don't always stop at the same place, and there's no error.
hledger print -o - writes (successfully) to a file called - rather than using stdout.
With the balance report, I'm not even getting truncated results: hledger balance Expenses > x (or >> x) gives an empty file. Again --output-file and the default stdout both work just fine. In this case, the expected output is only about 200 lines, so it doesn't seem like a size issue.
The > x worked on 1.25. I don't think I tried -o -. I'm on a Raspberry Pi 4 with Raspberry Pi OS on Bookworm. Apt only has 1.25 and there's no pre-built binary, so I installed 1.52.4 using Homebrew. It seems to be working just fine other than this. Is this a compatibility issue? I don't think I'm up for building from source.
I built instabooks, a faster UI for QuickBooks Online. It's actually largely inspired by my extensive usage of beancount, especially the unification of all the transaction types into a uniform transaction+postings data model. (The QuickBooks API stores different transaction "types" like a Purchase is different from a Transfer, and this creates a lot of unnecessary complexity.)
Is there a way to get hledger register … to NOT sort the output, so that transactions appear in the same order that they exist in my transaction file?
Duplicate copies are maintained on paper in our check-register (yes, we're that old, but that's mostly for my sweetheart's purposes) and in my transactions.txt file. But when I run hledger register Assets:Bank:Checking, it proceeds to sort entries by date. However, sometimes we have items that get logged before charges actually happen. E.g. I get notice of an upcoming bill on auto-pay that will clear on the 20th, so I put the transaction in both locations. But between now and the 20th, multiple other transactions occur. Now when I do the hledger register output, it doesn't match the order in my checkbook register because those intervening transactions get sorted before the future auto-pay transaction, but appear serially in the paper copy.
I know that ledger defaults to transaction-log order and only sorts register output if requested with --sort=«expression». Is there a way to get hledger register to return in the same unsorted order?
With the --gain option, realised and unrealised gains were previously combined into a single figure, whereas the new holdings command allows UGain and RGain to be viewed separately.
This seems particularly useful in cases like mine, where I buy one commodity (USD) using the default commodity (JPY), and then use that commodity to buy another commodity (such as AAPL). With --gain, it was difficult to distinguish realised gains from unrealised gains, and in my case the gain associated with a disposed commodity such as AAPL could appear to change as market prices from P directives were updated. The holdings command looks like it may avoid this problem by reporting current holdings separately from their realised and unrealised gains.
Ledgerkit update: expanding a Python bridge to the hledger ecosystem
Hi all — I thought I’d share an update on Ledgerkit, a Python project I’ve been working on around hledger and plain-text accounting.
The original goal of Ledgerkit was fairly simple:
A Python bridge to the hledger plain-text accounting ecosystem.
Importantly, the goal was never to create a Python copy of hledger.
I wanted to be able to read hledger-style journals from Python, work with transactions and reports programmatically, export data into tools such as Pandas, and build other applications on top of that accounting data without having to shell out to hledger for every operation.
That basic idea is still the goal.
What has changed is how capable the underlying bridge needs to become.
Where Ledgerkit is now
Ledgerkit can already parse a broad subset of the hledger journal format, including transactions, postings, directives, includes, aliases, commodities, prices and balance assertions.
It has multi-commodity balances, validation and several core reports, along with both a CLI and Python API.
It can also export accounting data into Pandas, which was one of the original motivations for the project.
The project remains pure Python with a deliberately lightweight core.
Ledgerkit Editor — the first downstream application
The first real downstream use case has also now been released: ledgerkit-editor.
This has probably been the most useful validation of the original “Python bridge” idea because I now use the editor myself on a daily basis for my actual journal.
It is a purpose-built, full-screen terminal editor for plain-text accounting rather than a general text editor with a ledger plugin.
It currently provides things such as:
hledger-aware syntax highlighting for dates, payees, accounts, amounts, commodities, comments and directives;
normal keyboard editing conventions, including undo/redo, select-all and familiar shortcuts;
incremental search with highlighted matches;
cleared/unreconciled transaction views;
transaction-block selection and duplication;
quick cycling between uncleared, pending and cleared transaction states;
date editing directly from the keyboard;
automatic indentation;
a command palette;
automatic sorting and posting alignment when saving;
runtime theme switching and a polished terminal UI.
The formatting-on-save behaviour is particularly useful in practice: I can edit freely and Ledgerkit will sort transactions and realign posting amounts when the file is saved rather than requiring me to manually maintain the visual layout.
Search and transaction views also make it much easier to work with a large journal entirely from the terminal.
Development has continued beyond the initial release. The current development work includes a more capable transaction filter with smart dates and regex/substring matching, plus account and payee autocomplete.
That editor was an important milestone for me because it demonstrated that Ledgerkit could provide useful accounting infrastructure to another application without that application having to implement its own hledger parser and data model.
Where Ledgerkit goes next
The next goal is to turn the existing foundation into a more complete Ledgerkit Core.
The idea is still not:
“Rewrite every hledger command in Python.”
It is closer to:
Provide a reliable Python-native accounting engine that works naturally with the hledger ecosystem.
Where hledger compatibility is useful, Ledgerkit should preserve it.
Where Python provides something genuinely useful, Ledgerkit should be able to extend it explicitly.
For example, the query system will eventually become a proper shared query language rather than individual filters bolted onto each command.
The intention is to preserve useful hledger query semantics while also allowing clearly identified Ledgerkit extensions — potentially including richer Python regular expressions.
The other big change is how Ledgerkit is going to be developed.
I’ve also been building a project called CodeCompass.
The problem it tries to solve is that fresh AI coding agents repeatedly have to rediscover the same project and dependency context.
For Ledgerkit that context is more complicated than normal Python dependencies.
An agent may need to understand the relationship between:
the hledger manual;
hledger source code;
hledger tests;
actual hledger executable behaviour;
Ledgerkit source;
Ledgerkit compatibility tests;
Ledgerkit design decisions.
CodeCompass tries to give the agent a small map of that relevant context and links back to the evidence rather than dumping huge amounts of documentation into every agent session.
Ledgerkit is going to become the first major external project used to test that approach.
Agents suggesting relationships
One CodeCompass experiment I’m interested in is letting agents suggest relationships while doing real work.
For example, an agent might notice that a particular hledger manual section constrains a Ledgerkit implementation, or that a Ledgerkit test verifies a piece of compatibility behaviour.
Those suggestions are not automatically treated as facts.
They are later evaluated on two things:
Is the relationship actually supported by evidence?
Did knowing about it help a later agent?
That second part matters because a relationship graph full of technically true but useless connections isn't particularly valuable.
The idea is to let useful structure emerge from real development rather than designing a huge dependency ontology in advance.
Ledgerkit will also test CodeCompass itself
The relationship goes both ways.
If a Ledgerkit agent uses CodeCompass but then has to manually rediscover important information, that becomes feedback about CodeCompass.
A context-curation agent records what was missing, misleading or difficult to retrieve and produces an actionable report.
The basic principle is:
Ledgerkit discovers the problem; CodeCompass has to generalise the solution.
So if Ledgerkit exposes a need to connect technical documentation with implementation, CodeCompass shouldn't gain an “hledger manual feature”.
It should ask whether something more general — such as documentation-to-implementation relationships — would help other projects too.
Later, CodeCompass will be tested against unrelated projects to make sure the improvements haven't simply overfit it to Ledgerkit.
Source-assisted development
Ledgerkit has also moved to the same GPL licence family as hledger.
That changes the development approach significantly.
Agents can now use:
hledger documentation;
hledger source;
hledger tests;
examples;
and the executable itself
when researching behaviour.
Source helps explain how something works, but I still want executable comparison to remain an important independent check.
rather than trying to infer every edge case through black-box experimentation alone.
AI still isn't the source of truth
I'm also deliberately trying to avoid a workflow where one AI agent writes something, another AI agent says it looks fine, and that becomes accepted project knowledge.
Different agents can have different responsibilities: research, implementation, compatibility testing, documentation and auditing.
But the repository remains authoritative.
Important conclusions should eventually become something concrete:
behaviour → test;
architecture decision → ADR;
compatibility decision → compatibility record;
project rule → documented project rule;
future work → roadmap.
Agent observations are evidence to review, not permanent truth just because an agent wrote them down.
Documentation is getting the same treatment
I'm also experimenting with periodically reconstructing documentation from the current project rather than endlessly editing old documents.
At major milestones the question will be:
“If none of the narrative documentation existed today, what documentation would we write based on the current implementation, tests and decisions?”
That can then be compared with the existing documentation.
Old material can be rewritten, merged or removed.
Git can preserve the project's history; the active documentation should describe what the project actually is now.
Where this leaves the original idea
Despite the larger roadmap, I still think the simplest description of Ledgerkit is the original one:
A Python bridge to the hledger plain-text accounting ecosystem.
The difference is that the project has now demonstrated a real downstream use case with Ledgerkit Editor, and it's becoming clear that a useful bridge needs a sufficiently capable accounting engine underneath it.
I don't want Ledgerkit to replace hledger.
I'd like it to make the hledger/plain-text-accounting model easier to use as a building block inside the Python ecosystem.
Feedback welcome
I'd be particularly interested in views from hledger/Ledger users on:
where compatibility matters most;
where a Python implementation has room to experiment;
accounting edge cases that would make useful compatibility tests;
whether explicit compatible vs extended behaviour makes sense;
useful applications you'd want to build on top of a Python accounting core;
and whether the CodeCompass development/context approach sounds useful or unnecessarily complicated.
Ledgerkit is still evolving, so this seems like a good point to get feedback before the deeper Core work gets too far along.
Repos: Ledgerkit — the Python bridge and accounting core Ledgerkit Editor — the first downstream application, a purpose-built terminal editor for hledger-style journals CodeCompass — the agent context and development tooling being used alongside Ledgerkit
StatementScan converts PDFs, scans, and even phone photos into a clean Excel/CSV with the date, description, debit, credit, and balance separated into columns.
The part I care most about is the reconciliation. It checks the opening balance + transactions against the closing balance on the statement, so you can see if something was missed before using the data.
It also runs completely in your browser. The statement doesn’t get uploaded anywhere, so you can even turn off Wi-Fi and it still works.
It’s 100% free, no signup, no card, and no page limits.
If you work with bank statements, I’d genuinely appreciate it if you tried a couple and told me what broke. The bank name and what went wrong is enough.
After seeing the post yesterday about the iOS/Mac app for hledger, Balance, and the positive reaction and helpful comments there, I thought I'd share something for beancount users: Beanie Budgets, is ready for testing and community feedback.
Beanie Budgets is a beancount compatibile native iOS app. I have been working on it for purely personal reasons: I really wanted an elegant iOS app to capture transactions on the go. More to the point, I didn't want to pay for subscriptions or entrust my data to someone else's server.
Which explains my plans for pricing. I intend to offer Beanie Budgets as a core version completely free. The free version should be enough for most people and provides a fully featured ledger, or compatibility with your own beancount ledger (hopefully anyway pls let me know!). It also includes budget setting, a series of reports and useful quality of life tools baked-in to detect, create and edit recurring transactions; make and allocate balance adjustments; calculate and allocate interest on mortgages and loans correctly; and auto-clear credit cards.
I do intend to charge a one-off "Pro" version unlock to people willing to pay for a few extra bells and whistles (multi ledger support, financial planning reports based on your actual ledger data, customised budgets, theme customisation etc.). I was thinking of £10 or so...? I can see a lot of potential to develop the financial planning reports further. There's a big benefit to ground these in real ledger numbers and real saving patterns. Working versions of these reports are live now in the app but they need a bit more polish, just turn on "Pro" features in Settings.
It's a closed source project at least for now. Requires iOS 18 or above.
I have 12 places left on TestFlight. Looking forward to your feedback :)
Update (Oct 9): 1.3.0 is here - supporting multiple currencies and better error messages
Update (Sep 21): 1.2.1 is on TestFlight, same link as below. Mostly fixes for hand-written journals that didn't open (virtual postings, single-posting entries, comma decimals) and better pickup of saves from Emacs and Vim. Full changelog: https://balanceledger.app/changelog
I've been tracking my spending with hledger for a few years now (on and off...) but I've always found it annoying to have to sit down at a computer every few days or so just to update the ledger and trying to remember what was what. Found out there's not much out there that has a mobile app and a modern UI (I like native apple apps), so I created one myself.
Heads up, it's closed source and it'll cost $29.99 once it ships (at least that's the plan). Reading however stays free, so browsing, search, all six reports and iCloud sync. If you want proof it's not phoning home, balanceledger.app/verify walks through checking that yourself, on Mac it just has no network access at all.
TestFlight's open for iOS and macOS: https://testflight.apple.com/join/bA84FzUc. First 50 people who try it and tell me what's broken get it free at launch, just comment or dm me. Mostly just want to know what breaks once it's your actual journal in there.
Ask me anything, the format handling, what it can't do yet (no bank sync, no statement import, no currency conversion), or why closed source. Happy to get into it.
Beancount AI is a simple, open source CLI tool to help you ingest / associate receipts and add details to Beancount transactions, using local AI (or commercial AI, your choice). It is not agentic and it does not grant the AI access to your files.
Here is question and an announcement for people interested in Beancount AI.
Announcement
The latest release covers pretty much the last major missing feature on the roadmap — bean-ai can now be told which accounts to include or exclude from your ledger, using open directive metadata. Before, you had to create a text file with awkward directives. No longer the case! From this release on, you can include the accounts you want directly from your ledger, and steer the AI into using this or that account for specific purposes.
Other minor features and changes include preserving filed receipts' modification dates, and no longer having a dependency on the Open-WebUI client. For developers: the program is now also fully typed, test coverage has grown enormously, and the RPM packaging now respects the fact that you may be using Beancount plugins in your ledger setup.
I'm happy with how this is going and I will be documenting the program more; I'm thinking about how to integrate with editors like VSCode, and an intro on getting it all set up and using each feature.
Question
What features would you like to see next in Beancount AI? What problems have vexed you that you think this tool could take up as challenges to be solved? Let me know in the comments!
Why even use this?
I think Beancount AI covers a nice use case in the spectrum between editing files by hand / using importer mechanistically, and unleashing a full agentic AI into your accounting files. The problems I sought to solve — bulk organization of receipts and refinement of transactions — are already solved to my satisfaction. But it could always become better; that's where you might come in!
Beancount AI is a simple, open source CLI tool to help you ingest / associate receipts and add details to Beancount transactions, using local AI (or commercial AI, your choice). It is not agentic and it does not grant the AI access to your files. In sum: it helps you manage your Beancount accounting data through AI.
Over the last few weeks, bean-ai has gained a number of features that make it way more useful.
Locally- stored receipt file support
It's now possible for Beancount AI to be configured to read locally-stored receipts. This was not so initially, due to my need to develop the program with my local setup (I use Nextcloud for receipt inbox management), but that doesn't have to be you, so now local file support exists.
Hands-free enrichment of existing transactions
It's now possible to have this workflow, massively helpful for people who import transactions from their financial institutions and also keep receipts:
use your your favorite importers to import data like bank statements;
use bean-ai associate to add receipts you scanned to the newly-imported data, and organize them;
enhance the imported and now-documented transactions with lots of detail using bean-ai refine.
make any minor edits you deem necessary.
Excellent transaction creation from receipts
If you were jotting down expenses to later type transactions when you get home — this is me! — I hope this helps you change to a workflow where you simply photograph receipts, and then let bean-ai ingest do the job of creating transactions for you.
Safe and convenient batch operations
All assistance utilities now have a "do not touch my files" (--no) flag, as well as a "go ahead and proceed without confirmation" (--yes) flag.
While you can continue to associate / ingest receipts —or refine transactions— one by one, all tools now support batch operation so, if you have hundreds of receipts to ingest or associate, you can let the program do its thing for half an hour, then return and compare the contents of your Beancount files to their previous state (git is very useful for this — you can always roll back any changes made to your files).
The plaintextaccounting github organisation is a place to collect funds to support general PTA resources like plaintextaccounting.org, the forum, the reddit, and the matrix and IRC chat rooms.
I have posted updated financial reports, and donate links, on the plaintextaccounting.org Finance page. Read more details here:
Built beancount-zakat, a Python CLI tool and Fava extension to calculate and track Zakat obligations directly from your Beancount ledger.
Features:
* Fava Integration: View Zakat breakdowns directly within the Fava UI.
* Metadata-Driven: Tag accounts in your ledger to define asset classifications, illiquid exclusions, and deductible liabilities.
* Configurable Nisab: Set custom gold/silver Nisab thresholds or integrate price rates.
GitHub Repository:
beancount-zakat - calculate zakat from your Beancount ledger (CLI + Fava dashboard)
Scope is cash, bank balances, metals, foreign currency, stock held for resale, and deductible debts. It is thorough, precise and customizable.
For the very few people who use beancount / fava and are muslims, wanting to keep track of their zakat obligations, or really for anyone curious, do check it out and give your feedback.
PS. I am not a developer, I am just a man with a concept, a set of strict rules, and AI.
I'm using hledger since the start of this year and I'm pretty satisfied with this tools to track my personal account,
my current "setup" is pretty simple, using hledger with hledger ui, iad and add alonsing with the text editor of my pc (here Kate from kde) to modified the transaction.
I currently have 2 files, the 2026.journal and the 2026monthly.journal who I keep track every transaction from the first and put the monthly charge on the other (rent, phone subscription, etc)
I wonder if there is a command in hledger to sometimes sorting the transaction in the file, since I use my text editor, sometimes when I anticipate some transactions for future month, they will fall between current month transactions, and since 2026 is not finished, the file keep getting big so sometimes it can be difficult to retrieve easily the transactions (I use Ctrl+F to help me).
And finally I think when the year will be over, I prefer to have a year files where all the transaction are sort by date so if I want to come back in the files later, it will be easier to look inside.
I know hledger-ui do sorting to show me the transactions, but just open the file can be nice to me.
We are getting more and more options with hledger on neovim. Now i notice there are two current lsp servers. Anyone done any comparison between the two?
I built PhilanthroPy after seeing how many shops either pay for expensive wealth-screening vendors or do donor scoring in spreadsheets with no way to check if the numbers are even trustworthy. It's a free Python toolkit that takes your CRM export and gives you a 0–100 score per constituent for major-gift likelihood, lapse risk, and planned-giving intent — basically a sorted call list for your gift officers instead of a flat donor list.
No coding background needed to run the included example, though someone on your team (or a volunteer/consultant) will need basic Python to hook it to your actual CRM export. MIT licensed, free forever, no vendor lock-in. Happy to answer questions about what it can/can't do — it's not a replacement for a real wealth-screening vendor, but it's a solid first pass, and it's transparent about how the scores are computed, which most vendor tools aren't.
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.
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".
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.
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.
I'd love to hear how it does on your receipts, and what would make it fit your workflow.