Turso Blog

Local first is amazing. I have been building a local first application for Invoicing since 2020 called Upcount https://www.upcount.app/. First I used PouchDB which is also awesome https://pouchdb.com/ but now switched to SQLite and Turso https://turso.tech/ which seems to fit my needs much better.

I’m not sure what they offer on this front, but turso is a new edge-based SQLite platform. It might be worth checking out: https://turso.tech/

See also, PGLite: https://pglite.dev/ And Turso: https://turso.tech/

This sounds a lot like https://turso.tech/ ? Unless I misunderstand, they're both pitching SQLite-for-the-cloud.

I thought the point of Turso was to offer better concurrency than SQLite currently does. A la https://turso.tech/blog/beyond-the-single-writer-limitation-with-turso… and https://penberg.org/papers/penberg-edgesys24.pdf Would be great if one of the Turso developers can clarify :)

I am a pretty serious "Rustacean", but I like to think "for the right reasons". A rewrite in Rust of the main project would make very little sense, unless there is some objective the project wants that can't be met with C (see below). This person presents a well thought out case on why it makes little sense to rewrite, especially in the final section. Rust is great for many things, but when you have something old that is already so well tested and accessible on all sorts of obscure platforms, it makes little sense to rewrite, and the likely result would be more bugs, not less, at least in the short term. All that said, some have found reasons to rewrite in Rust, and are currently working on that: https://turso.tech/blog/introducing-limbo-a-complete-rewrite-of-sqlite…

From the devs themselves[0]: >Our goal is to build a reimplementation of SQLite from scratch, fully compatible at the language and file format level, with the same or higher reliability SQLite is known for, but with full memory safety and on a new, modern architecture. And they call it rewrite in a recent followup post[1]. [0]: https://turso.tech/blog/introducing-limbo-a-complete-rewrite-of-sqlite… [1]: https://turso.tech/blog/we-will-rewrite-sqlite-and-we-are-going-all-in

"SQLite could be recoded in Go or Rust, but doing so would probably introduce far more bugs than would be fixed, and it may also result in slower code." We will see. On the Rust side there is Turso which is pretty active. https://turso.tech/

https://turso.tech I think attracts a lot of the people trying add new features / improve SQLite rough edges

> I needed 1 database per tenant ...Depending on how many tenants that is, Turso may fit your use case. https://turso.tech/

Their goal is to run this on their own cloud. Despite their lofty claims about community building, their projects are very much about forwarding their use case. Given that SQLite is public domain, they're not required to give anything back. So, it's very cool that they're making parts of their tech FOSS. But I've yet to see anything coming from them that isn't “just because we need it, and SQLite wouldn't do it for us.” There's little concern about making things useful to others, and very little community consensus about any of it. https://turso.tech/

> Take multi-tenancy. Using a SQLite DB per tenant is a good alternative to handle that: https://turso.tech/

> bundling an 80MB+ SQLite file to our codebase slowed down the entire Github repository and hindered us from considering more robust hosting platforms This seems like a decent reason to stop committing the database to GitHub, but not a reason to move off SQLite. If you have a small, read-only workload, SQLite is very hard to beat. You can embed it ~everywhere without any network latency. I'm not sure why they wouldn't just switch to uploading it to S3. Heck, if you really want a vendor involved that's basically what https://turso.tech/ has productized.

Turso (https://turso.tech/) offers a solution in that scenario. The advantage with SQLite being that each machine has a local copy of the database (optionally I think) for reads so it’ll be extremely fast, and writes happen to one primary database but are abstracted and replicated.

There's a company (http://turso.tech) that can host sqlite as a service. One of the features allows a replica local sqlite file to be used for reads and the writes still go to the primary on their edge network. Been using it (without the local feature) for a couple of months on a project and I will do it again for future products without a second thought.

This presentation is focused on the use-case of vertically scaling a single server and driving everything through that app server, which is running SQLite embedded within your application process. This is the sweet-spot for SQLite applications, but there have been explorations and advances to running SQLite across a network of app servers. LiteFS (https://fly.io/docs/litefs/), the sibling to Litestream for backups (https://litestream.io), is aimed at precisely this use-case. Similarly, Turso (https://turso.tech) is a new-ish managed database company for running SQLite in a more traditional client-server distribution.

Apparently Turso has a free $0 tier (yay!): https://turso.tech/pricing (Which makes it a good candidate for the following page, listing online database providers with free tiers) : https://github.com/255kb/stack-on-a-budget/blob/master/pages/database-… Related: YouTube video: "Getting started with Turso": https://www.youtube.com/watch?v=39KzlxHHnH0

Yea this seems like a gift for https://neon.tech/, https://turso.tech/ and https://developers.cloudflare.com/d1/. Planetscale is definitely popular and they get a lot of free advertisement from tech influencers (may change without the free tier) but most people I know in enterprise haven't heard of it.

I wonder if Turso https://turso.tech/ supports that use case. They support 10k databases in the step above free pricing tier.

ThePrimeagen (dev YouTuber: https://youtube.com/@ThePrimeagen) talks about liking Turso quite a bit, which is built on SQLite. I haven’t tried it, but it sounds fun. https://turso.tech/

you can use https://turso.tech for that, which makes SQLite replicated, and available over HTTP. It's designed to work on environments where LiteFS won't (since it needs a volume).

> However, it's only meant for local systems. Once you need to connect over a network or robustly handle simultaneous requests That’s not really accurate any longer. Mostly depends on how you layout your tables & files. If you shard the databases then multiple machines can act as writers for their shard. You can also split read requests from write requests and have read only machines scale up/down as much as you’d like. You can use multiple files in a query (there is a limit there). So for example you can split the user table based on the first letter of the username and then depending on the rest of the database either a database file per user or per customer (organization). Of course more of everything is manual but it’s not as hard as you’d expect if you build for it. https://rivet.dev/blog/2025-02-16-sqlite-on-the-server-is-misunderstoo… If you need sqlite over the network you can look at https://turso.tech/ it’s a almost drop in replacement for sqlite (https://github.com/tursodatabase/turso/blob/main/COMPAT.md)

> The language design contract is unsafe by default False. The language design safe by default, something that you can confirm super easily doing just the Rust tutorials and compare the same with C or C++. Read the repo well: cve-rs implements the following bugs in safe Rust: Use after free Buffer overflow Segmentation fault NOT REFUTE IT. > There are unsafe blocks all over the stdlib Unsafe blocks is not the same that unsafe code. Are marked areas that are required to do escape automated checks, and there, you are at the level of a C/C++ programmer (where in that languages ALL THE CODE IS MARKED UNSAFE). If you complaint against that, is the same as complaint against ALL THE CODE writer on C/C++. --- One thing important to understand about Rust: Rust is a system language and SHOULD be able to implement everyting including, Buffer overflow, Use after free , Segmentation fault and such. You should be able to implement a terrible OS, malware, faulty drivers, etc, minimally because that is required to test safe programs! (example: Deterministic Simulation Testing https://turso.tech/blog/introducing-limbo-a-complete-rewrite-of-sqlite… But what Rust gives is that not assume that you want to do it for most programs.

As you might know not one tool fits all, I still have strong preferences for the following. It helps me get going faster and get things done right first time and helps in ease of maintenance. Language: Typescript. Frontend Framework: Astrojs [1] or qwik [2] Frontend Library: React if it requires 3d and other frame-motion like animations, else will not use any frontend library or might throw solidjs if required for some state etc. Backend: Cloudflare functions, google functions Auth: Lucia-Auth [3] if required IDE: VS code with neovim , once deployed to git, I might some time use code-spaces CSS: DaisyUI [4] with tailwind or Bulma CSS Library: TailwindUI [5] makes most of the components ready to use and comes from the makers CMS: Astro content collections or Sanity [6] Deployment: Cloudflare (Highly preferred) or linode/digitalocean/netlify Database: turso [7] or neon postgres [8] with (drizzle orm) or cloudflare durable objects 1. https://github.com/withastro/astro 2. https://github.com/BuilderIO/qwik 3. https://github.com/lucia-auth/lucia 4. https://github.com/saadeghi/daisyui 5. https://tailwindui.com/ 6. https://www.sanity.io/ 7. https://turso.tech/ 8. https://neon.tech/ Also huge fan of firebase and their emulators and whole eco-system.

Is it a similar job to https://turso.tech/

Turso might be a fit https://turso.tech/

And Turso! <3 https://turso.tech/

Wow, people have been working hard for a long time in Turso: https://turso.tech/blog/introducing-limbo-a-complete-rewrite-of-sqlite… to do the same cursor did in justo no time?

Case study: Turso[1] Rewrite the open source SQLite in Rust under an MIT license[2]. Of course, once you complete the core product, there is the extended ecosystem to consider. [1] https://turso.tech/blog/introducing-limbo-a-complete-rewrite-of-sqlite… [2] https://github.com/tursodatabase/turso

This needs to be read after the article from Turso on how they're retiring their bug bounty program because of being inundated with useless AI slop reports. It's the top story on HN right now. https://turso.tech/blog/the-wonders-of-ai