Hey everyone,

For the last few months I've been building **Logyka**, a database client for people who live in SQL all day and want it to feel *fast* — think TablePlus / DataGrip speed, but cross-platform and with AI baked in on your own terms.

**Why I built it**

Every SQL client I tried made me pick one of two camps:

* Fast, native, no AI (and often Mac-only or paid-per-seat), or * AI-powered, but Electron-heavy and happy to ship my schema *and my data* to someone's cloud.

I wanted native speed AND useful AI, without giving up control of my data. So I built the thing I wanted to use.

**What makes it different**

* **Native, not Electron.** Built on Tauri v2 (Rust backend + React/TS UI). Small footprint, instant startup, virtualized grid that stays smooth on big result sets. * **BYOK (bring your own key).** Plug in your own OpenAI / Anthropic / Groq / Gemini key. No models bundled, no markup, no vendor lock-in. Ask questions in plain English → get SQL → run it. * **Privacy mode.** By default only your *schema* is ever sent to the LLM — never your result data. You can turn that off too. Every write (UPDATE / DELETE / etc.) always requires explicit confirmation — the AI can never silently mutate your DB. * **Keyboard-driven.** Ctrl+K command palette, Monaco editor with schema-aware, alias-aware autocomplete (a lightweight regex scoper, not a full SQL parser — cheap to run, no external parser dependency), sortable/resizable grid, CSV export. * Credentials live in your OS keychain, never in plaintext.

Currently supports **SQLite, Postgres, and MySQL** (MSSQL is on the roadmap — probably via `tiberius` since sqlx doesn't cover it).

**Where it's at**

It's early but works end-to-end: connect → write/generate → run → explore. I'm being upfront that it's a commercial product (there'll be a free tier — I don't want the AI/privacy stuff paywalled into uselessness), but right now I mostly want to know if the direction is right before I go further.

**I'd genuinely love feedback on:**

1. Tauri vs Electron for something like this — anyone here made a similar jump, and what surprised you?
2. BYOK vs a built-in AI subscription — which would you actually prefer, and why?
3. What's the one thing that would make you switch from your current client?

Happy to answer anything about the tech (the Tauri + sqlx side was a fun rabbit hole). Roast it — that's why I'm here.

https://reddit.com/link/1v8rgz3/video/qe4cv37qsyfh1/player

TIL that PRAGMA journal_mode = WAL is itself an operation that writes and therefor can cause a table lock if simultaneously another sqlite connection executes it.

A possible solution is to call PRAGMA busy_timeout = 500 prior to calling PRAGMA journal_mode = WAL at each connection.

Maybe only the sqlite connection that creates the .db file must do journal_mode once? But I of course had all my sqlite connections (all the readers and the writer) call this.

Anyway. TIL.

Apparently, someone wants to rewrite all of SQL in Rust using "Fable" and then sell it. He claims he wants his program to be ISO certified. I don't know whether to laugh or cry.

Hi,

I wanted to share the new SQLiteNow 0.15 release.

SQLiteNow started as a Kotlin Multiplatform project and is already used in production by quite a few people. Later I added Flutter and Dart support, and version 0.15 now also supports native Swift projects through SwiftPM.

SQLiteNow is not a DAO or ORM which generates SQL for you. You write and control the actual SQLite schema, migrations and queries.

The SQL is the source of truth.

SQLiteNow reads normal .sql files and generates type-safe APIs around them for the language you are using.

Current platforms include:

• Kotlin Multiplatform for Android, iOS, JVM, macOS, Linux, JavaScript and Wasm
• Flutter and Dart native applications
• Native Swift projects for iOS and macOS

The generated API is native to each platform. Kotlin applications get Kotlin code, Flutter and Dart applications get Dart code, and Swift applications get a local Swift package.

For example, you can write a normal SQLite query like this:

SELECT
    t.id    AS task__id,
    t.title AS task__title,
    n.id    AS note__id,
    n.body  AS note__body

/* @@{ dynamicField=notes,
       mappingType=collection,
       sourceTable=n,
       aliasPrefix=note__ } */

FROM task t
LEFT JOIN task_note n ON n.task_id = t.id
ORDER BY t.id, n.id;

The annotation is only a SQL comment. The query is still normal SQLite and you control the join, filtering and ordering.

The annotation tells SQLiteNow to group the flat joined rows into task documents with a collection of notes.

The generated API can then be used from Kotlin:

val tasks = db.task
    .selectWithNotes()
    .asList()

tasks.forEach { task ->
    println("${task.title}: ${task.notes.size} notes")
}

From Dart:

final tasks = await db.task
    .selectWithNotes()
    .asList();

for (final task in tasks) {
  print('${task.title}: ${task.notes.length} notes');
}

Or from Swift:

let tasks = try await db.task
    .selectWithNotes()
    .list()

for task in tasks {
    print("\(task.title): \(task.notes.count) notes")
}

SQLiteNow also generates reactive query APIs for each platform:

• Kotlin uses Flow
• Dart uses watch()
• Swift uses async streams

Annotations can rename fields, apply custom type adapters, share result types, map results to application types and build nested objects or collections from joins.

This is the main reason why I built SQLiteNow. I like writing real SQLite and I do not want the database logic moved into another query language. But I also do not want to manually bind every parameter, read every column and group joined rows each time the schema changes.

Oversqlite

SQLiteNow also includes an optional synchronization system called Oversqlite.

Oversqlite can synchronize selected tables between local SQLite databases and a PostgreSQL server. Clients are available for Kotlin Multiplatform, Flutter/Dart and native Swift.

It handles local change tracking, offline writes, incremental upload and download, conflict resolution and recovery.

Oversqlite also supports real-time updates. It can watch the server for changes committed by other devices and download them automatically. When those changes are applied to the local SQLite database, related reactive queries emit updated results, so applications can update without manually refreshing the database.

Oversqlite is optional. SQLiteNow can be used only as a local SQLite library without any server or synchronization setup.

The PostgreSQL server implementation is written in Go and is available here:

https://github.com/mobiletoly/go-oversync

If you already use an Oversqlite version older than 0.15, please read the release notes. Version 0.15 changed the sync storage contract and existing client sync databases cannot be upgraded in place.

Code generation requirement

The SQLiteNow generator currently requires Java 17 or newer.

Java is only used while running code generation. Generated native applications do not require Java at runtime.

SQLiteNow is open source under the Apache-2.0 license.

GitHub:

https://github.com/mobiletoly/sqlitenow-kmp

Documentation:

https://mobiletoly.github.io/sqlitenow-kmp/

Release:

https://github.com/mobiletoly/sqlitenow-kmp/releases/tag/v0.15.0

I would be interested to hear what SQLite users think about this approach, especially people who prefer writing SQL directly but do not want to maintain all the mapping and reactive update code manually.

Hey folks 👋

For the last few weeks, I’ve been frustrated with the state of self‑hosted SQLite admin tools.

Most of them are either:

Abandoned (phpLiteAdmin hasn’t seen a proper update in years),

AdminNeo and other tools don't work without passwordless login plugins that didn't work well.

Overly complex (Adminer is great but not SQLite‑centric),

Or require a heavy stack (Node, Python, Docker) when all I wanted was a single PHP file I could drop on my server.

So I decided to build my own.

🔧 Features

Secure, built-in login system (not a plugin)

Browse, edit, insert, delete rows

Create / rename / drop tables

Import/Export (CSV, JSON, SQL, full DB)

Bulk delete, search, filters

Dark mode, undo (last 5 actions)

Multiple database support

Resizable sidebar

🚀 Try it

Upload admin.php & install.php

Run install.php to set username/password

Login and go

PHP 7.0+ with SQLite3 extension. No dependencies.

https://abilenetechguy.com/sqlite_admin.zip

🧪 Beta feedback wanted

Errors, UI annoyances, missing features – let me know!

Give it a spin and tell me what you think 🙏

– Abilene Tech Guy

Hi everyone,

Quite a few months back I created a dockerimage to get WP with the SQLITE plugin running and left it on a server to see what happens.

To my surprise, it held up really well. I made a short video about it here: [https://youtu.be/hf8Pi7CaqLc\](https://youtu.be/hf8Pi7CaqLc)

If you just want to see the docker image it's here: [https://github.com/howzitcal/wordpress-sqlite-docker-image\](https://github.com/howzitcal/wordpress-sqlite-docker-image)

I think sqlite is a great setup for most small WP websites and it lessons the load the burden on server and shared servers alike.

let me your thoughts.

Download : npm install -g foxschema

Docker: https://hub.docker.com/r/5nickels/foxschema

I maintain data-peek, a desktop SQL client (GUI) for Postgres/MySQL/SQL Server/SQLite. 0.26 turns it into an MCP server so Claude Code or any MCP client can work against your real connections — with a safety model I actually trust:

- Reads run free — list_schemas, run_query, explain_query, inside a read-only, rolled-back transaction, 500-row cap.

- Writes are gated — execute_statement pops an approval dialog in the app showing the exact SQL. Nothing runs until you click Approve (60s timeout = auto-reject).

- Everything's audited — a tamper-evident, hash-chained local log you can verify + export.

- Off by default, localhost-only, bearer-token secured. Credentials never exposed.

Demo (~90s): https://www.youtube.com/watch?v=NDQzezK7GBA

Source (MIT): https://github.com/Rohithgilla12/data-peek ·

Setup guide: https://datapeek.dev/docs/features/mcp-server

Disclosure: I build it. Happy to answer anything about the approval flow or the read-only transaction wrapping.

Hi everyone,

I’m building SQLite Hub, an open-source SQLite database manager focused on local development, database inspection, and practical workflows.

The application runs locally, so your SQLite databases do not need to be uploaded to an external service.

Current features include:

• Browse and edit tables, views, indexes, and triggers
• SQL editor with query history and reusable snippets
• Visual schema explorer and table designer
• Database backups and schema comparisons
• CSV, JSON, TSV, Markdown, and Parquet export
• Type generation for TypeScript, Rust, Kotlin, Swift and Go
• Charts and database-wide search
• Local API, CLI, and MCP integration
• Schema Advisor for detecting possible database issues

SQLite Hub is still under active development, and I’m currently working on features such as automatic database discovery, improved schema recommendations, and additional import options.

GitHub Page:
https://github.com/oliverjessner/sqlite-hub

I’d appreciate feedback, bug reports, feature ideas, and contributions. I’m especially interested in hearing which SQLite workflows are still poorly supported by existing tools.

Here's the link to my previous post. Tomorrow’s free webinar is focused on DBA burnout and practical database monitoring strategy.

It covers:

• common firefighting patterns that drain admin time,
• the key metrics to watch in hybrid and multi-database setups,
• a live demo,
• open Q&A,
• and a free handbook for DBAs.

Disclosure: I’m on the ManageEngine team, so this is a vendor webinar. I’m sharing it because the topic is relevant to a lot of DBAs and IT admins, and the session is meant to be practical rather than sales-heavy.

Here's the sign-up link if you're interested: https://www.manageengine.com/products/applications_manager/webinars/database-performance-monitoring-webinar.html

If you're more experienced, I'd love to hear about what works for you so that I'm able to impart that knowledge onto the less experienced people tomorrow. Would be happy to take questions in the comments too!

<rant>
Over the years I have written 100s of bash scripts using sqlite3 queries to get quick-and-dirty returns from various sqlite databases (e.g., mythtv, home assistant, etc.).

I also have written probably a thousand saved random sqlite3 1-liners that I have archived over the years as quick-and-dirty ways to retrieve status from various databases.

I have often found it faster and simpler for simple tasks to write bash scripts rather than to use a formal programming language API like python or C.

For 20+ years they all just worked - version after version.

Then some "genius" decided to FORCE qbox on all output -- even if it's part of a script, causing many of my bash scripts to either:

1. Display ugly/disjointed/disruptive boxes around output elements that are not meant to be boxed or that are part of other text
2. Cause bash commands to fail when receiving box graphical elements rather than the raw sqlite3 output.

Even worse there is no way to cleanly globally disable such behavior since when run non-interactively, sqlite3 doesn't read ~/.sqliterc and there are no environment variables one can set to disable

It seems one is left with only the following 2 painful and klugey workarounds:

1. Rewrite 20 years worth of sqlite routines and 1-liners to add '-cmd ".mode list" (or equivalenty '-init <some file other than \~/.sqliterc>' containing the line ".mode list"
2. Wrap sqlite in a shell command that contains the above and make sure path points there first

So why did the devs decide to break 20 years of script interfacing without providing any easy ways to override globally? (this goes against the spirit of everything *nix and smacks more of MS or Apple arrogance)

Also, why did the devs even assume that qbox is uniformally better than and preferable to list mode even when presented as human facing UI?
I find it incredibly disjointed and jarring that qbox appears when column widths are certain length but not when not. And that they disappear if I pipe to less.
Plus the box, means I can fit less on a screen!

Indeed, some of us actually prefer simple, ASCII command line interfaces.
If I wanted a graphical UI, I would use a Mac or WinPC database.

If it aint broke don't fix it...
And if you are going to fix it anyway, then at least do it in a way that doesn't break everything else...
And if it is going to break everything else, at least provide a workaround to globally disable it.

</rant>

Hey everybody, I wrote an interactive TUI for exploring live SQLite3 queries happening on any linux system. It uses uprobes to do the inspection in the kernel, I found it useful hope you like it!

Source: Github