TigerBeetle Blog

One of the preeminent Zig software projects, Tigerbeetle[1], has a great website[2] and markdown file[3] for what they call TigerStyle. It's honestly a great read as a human but also I packaged it as a skill and saw coding agent improvement, especially around memory usage. 1. https://tigerbeetle.com/ 2. https://tigerstyle.dev/ 3. https://github.com/tigerbeetle/tigerbeetle/blob/main/docs/TIGER_STYLE.…

Joran from TigerBeetle! Without much sweat for general purpose workloads. But transaction processing tends to have power law contention that kills SQL row locks (cf. Amdahl’s Law). We put a contention calculator on our homepage to show the theoretical best case limits and they’re lower than one might think: https://tigerbeetle.com/#general-purpose-databases-have-an-oltp-limit

The test simulator/game starts at ~17:50 For those jumping to the comments wondering if it's worth watching: TigerBeetle[0] is a database for managing financial transactions. They extend the testing practices of FoundationDB (now spun out into Antithesis[1]), going a layer deeper to test for data integrity when there is disk io corruption (~20:30) In the demo, they have created a game-like simulation that runs in the browser. You can watch Joran "attack" database nodes and simulate corruption. The entire presentation is impressive and the simulator is very entertaining. [0] https://tigerbeetle.com [1] https://antithesis.com

I believe TypeScript and Rust are both strong examples of languages that do this (for different reasons and in different ways). It's also possible for a language to raise the ceiling of software quality, and Zig is an excellent example. I'm thinking of "floors" and "ceilings" as the outer bounds of what happens in real, everyday life within particular software ecosystems in terms of software quality. By "quality" I mean all of capabilities, performance, and absence of problems. It takes a team of great engineers (and management willing to take a risk) to benefit from a raised ceiling. TigerBeetle[0] is an example of what happens when you pair a great team, great research, and a high-ceiling language. [0] https://tigerbeetle.com/

> There is no reason to use a memory unsafe language anymore, except legacy codebases, and that is also slowly but surely diminishing. I'm still yet to hear this amazingly compelling reason that you just need memory unsafe languages. In terms of cost/benefits analysis, memory unsafety is literally all costs. Tell that to the authors of new memory unsafe languages (like Zig) and creators of new projects in those languages (like https://tigerbeetle.com) :(

For those interested, Tigerbeetle[0] is a high-peformance purpose built accounting database. It supports - double entry transfer - two-phase transfers (ie reserve an amount and post it later) - linked transfers (move money across multiple accounts atomically) Worth looking at. [0] - https://www.tigerbeetle.com/ & https://github.com/coilhq/tigerbeetle

I really like the work Joran and his team have done around DST, distributed systems awareness, and performance practices. I especially love the craziness around no dependencies (well, could you consider an underlying OS a dependecy?). But I've always felt the way they treat normal OLTP (they call OLGP) seems unfair. For example, comparisons using clear sub-optimal interactive SQL transactions for financial workloads, like locking rows rather than using condition checks at commit time, because "that's how OLTP was intended to be used when it was designed ~50(?) years ago". In their cited https://tigerbeetle.com/#performance the lowest the slider can go is 1% contention. Do you think Stripe has 1% contention directly on an OLTP DB? Definitely not. You can build systems that _expect contention_, and elegantly handle it at REALLY high throughput. These systems protect the DB from contention, so you can continue to scale. From talking to folks working on these systems, I roughly know the kinds of transactional (financial) throughput of DBs like Stripe's and other systems - they have _many_ more zeros behind them than their performance comparison page proposes they could possibly have at even 0.01% contention. Their marketing largely ignores this fact, and treats everyone like they just slam the DB with junior engineer-designed interactive transactions. Most developers (I hope) are smarter than that if they're working at a payments company. There's even the title "payments…

> Bun has had an extremely high amount of crashes/memory bugs due to them using Zig This just sounds like they are not good at using Zig. I have been daily driving ghostty on linux for a fairly long time now and I have never seen these kinds of issues. I have also used ghostty on macos for a bit and didn't have any problems there either. Zig is really good for writing stable and reliable code. There is also a database written in Zig that seems to be fairly successful [0]. I also wrote zig for some time and compiler/toolchain was really pleasant to use. I wrote more segfaults in Rust ffi code than all segfaults I had in Zig in total while I was writing Zig. [0] https://tigerbeetle.com/

Gee, good thing I didn't make a blanket statement and qualified it by saying "often", which is true, my contrarian dude. https://tigerbeetle.com wouldn't have chosen it unless they found it faster than C- and there's a significant quantity of money riding on that decision, so it likely wasn't done lightly at all. The rest, you can google yourself, but in short, sorry to tell you that it is sometimes faster. Often, sometimes, some portion of the time.

There's an actual production grade database written in zig: https://tigerbeetle.com/

TigerBeetle's excellent companion blog - https://tigerbeetle.com/blog/2025-10-25-synadia-and-tigerbeetle-pledge…

The way I understand it yes. Latency will be dictated by going to the leader node and replication to enough followers. The CAP theorem dictates that if you want strong consistency the way they offer you have to talk to a quorum of nodes IIRC N/2 + 1. Paxos and Raft also work that way. Apparently there is a game about it https://tigerbeetle.com/blog/2023-07-11-we-put-a-distributed-database-…

yes. most folks don't seem to understand this. but, you can get something approaching such guarantees if you are able to limit yourself to something as (seemingly) simple as updating a ledger. this approach is used in a lot of places where high performance and strong consistency is needed (see e.g. LMAX disruptor for similar). https://tigerbeetle.com/

zig is coming along quite nicely. If you've not heard about zig, take a look at https://ghostty.org/ (a terminal for Linux/Mac and Windows in future), https://tigerbeetle.com (a database for financial accounting) and http://bun.sh (a modern, faster alternative to nodejs).

Zig doesn't promise language or stdlib stability yet, but in reality the changes are quite manageable. And it's already good enough for some high-profile real-world projects like Bun (https://bun.sh/), Tigerbeetle (https://tigerbeetle.com/) or Ghostty (https://ghostty.org/). In the end, language stability isn't as important as it used to be, people are quite used to fixing their code when upgrading dependencies to a new major version for instance.

Also there are now databases purpose built for specific domains. E.g. if you are building a financial ledger I would way rather be interfacing with TigerBeetle than scaffolding an application-driven ledger around Postgres. https://tigerbeetle.com/. If I am scraping giant amounts of data I would run far away from Postgres for other databases like Amazon Redshift.

Then maybe point of one of those databases: https://foundationdb.org/ https://tigerbeetle.com/ Or if you really wanna keep the SQLite theme: https://github.com/losfair/mvsqlite Why promote the vaporware project when comparing with something that's been in development for 10 years?

Btw for those wondering what to do instead is to simply use https://tigerbeetle.com/

The TigerBeetle database is built this way, and I kind of love the concept https://tigerbeetle.com/blog/a-database-without-dynamic-memory

Why would you want to build your own accounting ledger from scratch? Accounting is a completely new domain for most engineers, and TigerBeetle (https://tigerbeetle.com/) already solves this problem.

A fancy new database is written in Zig: https://tigerbeetle.com/

TigerBeetle is using Zig in production.[0] I imagine some of Zig's other corporate sponsors are using it as well.[1] [0] https://tigerbeetle.com/ [1] https://ziglang.org/zsf/

They have done great contribution for async I/O in the Zig community: - io_uring support on the std lib https://github.com/ziglang/zig/pull/6356 - a cross-platform io_uring based event loop https://github.com/tigerbeetledb/tigerbeetle/tree/main/src/io https://tigerbeetle.com/blog/a-friendly-abstraction-over-iouring-and-k… Thanks team

https://bun.sh/ https://tigerbeetle.com/ https://www.youtube.com/watch?v=SCj2J3HcEfc ;^)

It's username-404. Replying from here because I can't remember my password. > https://bun.sh/ From their GitHub: "Bun is experimental software". > https://tigerbeetle.com/ From their GitHub: "TigerBeetle is not yet production-ready". > https://www.youtube.com/watch?v=SCj2J3HcEfc (Uber) From the linked blog post "Uber does not have any plans to use zig-the-language yet." :( I was referring to production-ready examples.

I wonder if they considered https://tigerbeetle.com

This is very much alive for internal tools, but the importance of design from a product perspective has proven important, which is why you don’t see much in products anymore. This is revisionist history. Desktop environments had become so complex and fragmented that just writing HTML & CSS seemed incredibly appealing. "the importance of design from a product perspective has proven important" is unsubstantiated, and is justification after the fact. Those are just buzzwords, what exactly do you mean by this? A focus on information vs a focus on 'engagement'. Knowledge vs addiction. Feeling better after using a computer as opposed to feeling worse. SQL is alive and well, granted newer programmers don’t learn it as early as they should Unfortunate use of words on my behalf, see: https://news.ycombinator.com/item?id=38243753 static memory allocation The tigerbeetle database is all statically allocated and (as I understand) makes no memory allocations as a response to use requests. They seem to be having great success with this approach. https://tigerbeetle.com/blog/a-database-without-dynamic-memory/ Another buzz term. Software is constantly designed and the design of software is constantly discussed. What exactly do you mean by this? Who forgot what? I don't feel like this is a buzz term. Agile or whatever one wants to call sprint based work flows means no serious design gets up front anymore, and so we constantly try and code our way out of anemic or non-existent…

Tigerbeetle uses LMAX: https://tigerbeetle.com/

In about 5 years time the trend will be "Just use Beetles" for everything :P Seriously Can't wait to see this. Congrats on launching [1] Tigerbeetle Cloud. Should have submitted that as well but I thought this was more interesting. May be another time. [1] https://tigerbeetle.com/cloud

Read TigerBeetle's own * A Database Without Dynamic Memory Allocation[1] * A Programmer-Friendly I/O Abstraction Over io_uring and kqueue[2] * Writing High-Performance Clients for Tigerbeetle[3] [1]: https://tigerbeetle.com/blog/2022-10-12-a-database-without-dynamic-mem… [2]: https://tigerbeetle.com/blog/2022-11-23-a-friendly-abstraction-over-io… [3]: https://tigerbeetle.com/blog/2023-02-21-writing-high-performance-clien…