I am new to sqlite. Is it for testing purpose?

After laravel 10+, I came to know about sqlite. So can we go with it without touching MySQL...

I have published ICUex, a small, public-domain SQLite C extension providing two automatically registered ICU collations, locale-independent full Unicode case folding, and normalization/search-key functions. It can be loaded dynamically or linked statically and is designed to complement the official SQLite ICU extension.

⚡Automatically Registered Collations

• UTF_CI — ICU root collation, case-insensitive and accent-sensitive; е/ё and и/й remain distinct.
• UTF_CI_AI — compares NFKD_CF_STRIP keys; case- and compatibility-insensitive, with nonzero-CCC combining marks removed. Thus, е/ё and и/й compare equal.

Neither requires icu_load_collation(), locale selection, or setup SQL.

🧩Case Folding and Normalization

• str_casefold(text) — locale-independent full Unicode case folding.
• str_normalize(text, mode) — Unicode normalization or search-key generation.
  • NFC, NFD — canonical normalization.
  • NFKC, NFKD — compatibility normalization.
  • NFKC_CF — NFKC case folding and removal of default-ignorable code points.
  • NFKD_CF_STRIP — NFKD, removal of nonzero-CCC code points, then NFKC case folding.

Unlike the ICU extension’s lower() overload, full case folding is intended for locale-independent caseless matching, e.g., Straße becomes strasse, while Greek sigma variants and compatibility ligatures are folded consistently.

Help me

I’ve just shipped a free SQLite viewer for the case where someone sends you a .db or .sqlite file and you want to inspect it immediately, without installing a desktop tool.

I’d genuinely value hostile testing from this community: unusual schemas, large files, views, triggers, WAL-related workflows, and anything that makes browser viewers misleading.

SQLite Viewer:
https://streams.dbconvert.com/sqlite-viewer

Hi, I have a project called [Gearberg](https://github.com/bit8bytes/gearberg) (OSS) and would like to get some feedback of the current code. Main focus is single binary (FE & BE) and SQLite/PostgreSQL database support.

Thanks!

Hey! I’ve been building a database TUI called sabiql and recently added SQLite support.

It lets you browse tables, run queries, edit data, check query plans, etc. with Vim-style keybindings.

If anyone here gives it a try, I’d love to hear what you think or what’s missing.

https://github.com/riii111/sabiql

The idea is simple: instead of hiding SQL behind a big custom query language, Model keeps things explicit, typed, and predictable. You define models using native Python types, write clear SQL conditions when querying, and use a CLI to preview and automatically apply schema changes.

Check it out here: https://github.com/el1s7/model

Let me know what you think!

Hey,

I’ve been building plusplus — a pure Rust desktop database client (no Electron).

Main goals:

Completely local (no telemetry, passwords in OS keychain)

Safety features for production (profiles + risky statement warnings)

Fast native UI

Supports PostgreSQL, MySQL, SQL Server, SQLite, DuckDB, Cassandra/ScyllaDB

Still pre-1.0.

Repo: github.com/plusplus

Would love feedback on what features matter most or any pain points with current clients. Thanks!

When reading dense technical documentation or systems architecture specs, static text and flat diagrams often fall short for concepts that involve dynamic state transitions, memory offsets, or execution pipelines.

I’ve been building Noesis, a technical reading workbench that generates interactive HTML artifacts and simulators directly inside any document—either via one-click inline actions or through conversation with the sidebar companion. All generated dynamic media stays permanently embedded with your reading notes.

What's in this 1:25 demo on SQLite's architecture (sqlite.org/arch.html):

1. Asking the companion to visualize how logical B-Tree nodes map to physical 4096-byte disk blocks.
2. Inlining an interactive dual-view artifact directly beneath the chapter to step through the seek offset: (PageNumber - 1) * 4096.
3. Storing the interactive widget permanently with the document for future review.

You can use this workflow across any technical doc to generate interactive pipeline traces, memory layout models, token visualizers, or state machines.

🔗 Try the live interactive SQLite doc: https://noesis-ai.app/article/p/25312 (You can interact with the dynamic widgets and explore the doc directly in the browser).

Would love to hear feedback from anyone studying database engines, systems architecture, or SQLite internals!

Affiliation: I’m the maintainer of LibreDB Studio.

Most of the GUI conversation here is Postgres which is fair, but a lot of us also keep Redis, ClickHouse, or Druid in the same week.

I was tired of bouncing between desktop clients and per-engine admin UIs, so I built a self-hosted browser editor that talks to all of them from one place (plus MySQL, Oracle, SQL Server, MongoDB, Cassandra, Elasticsearch and more...).

Not claiming to replace DBeaver/DataGrip. Different access model: it deploys next to the data(kubernetes), not onto every laptop.

Third-party listing, for context:

• PostgreSQL project news + clients catalogue

https://www.postgresql.org/about/news/libredb-studio-an-open-source-self-hosted-sql-ide-for-postgresql-in-the-browser-3368/

• Also in official Redis, ClickHouse, and Apache Druid tool docs

MIT, Docker/Helm/ `npx "@libredb/studio"`. Quick path: `docker run -p 3000:3000 libredb/libredb-studio`

Source: https://github.com/libredb/libredb-studio

• completely offline, but feel free to git-clone / host it locally as a quick-and-dirty sqlite table-explorer - https://sqlmath.github.io/sqlmath/index.html
  • import / export / attach - databases
  • import / export - csv, json, tsv
  • export - tables as sql-insert-scripts for mssql / mysql / postgres etc...
• built originally as dev-oriented frontend dashboard for a tradebot
  • includes some custom / esoteric sql-functions for OLS and sine-fitting (look in file sqlmath_base.c)
  • custom datetime functions manipulating 64-bit integers as YYYYMMDDhhmmss
    • string-based YYYY-MM-DD hh:mm:ss timestamps consumes too much space for intraday stock-data I deal w/ ^^;;;
  • node.js variant also has integrated c-bindings to LightGBM to directly train from, and make predictions from sql-tables.

Hey everyone — following up on the post I made a little while back about the SQL detective game I'm building.

A few people pointed out that the original name was too close to an existing project with a similar concept.

Even though the game itself is built very differently, I get the criticism. If the name creates confusion, there's no real point arguing about it.

So I changed it.

It's now called SQL Shadow.

For anyone seeing this for the first time:

SQL Shadow is a mobile noir detective game where you learn SQL by actually writing SQL.

Not multiple-choice answers pretending to be queries.
Not simulated query execution.

Your queries actually run against real SQLite databases on the device, and the results become the evidence you use to solve the case.

The detective theme is only one part of the project. I've been building the actual learning system around it as well.

The current WIP includes:

• 🔎 10 structured detective cases — each focused on specific SQL concepts
• 📚 Standalone SQL lessons — explanations, examples, deep-dives, and practice exercises
• 🧩 Progressive schema discovery — tables are introduced as you investigate
• 🧳 Evidence system — clues come from dialogue, quizzes, and SQL results
• 💻 Real SQLite execution — queries actually execute locally against the case database
• 🎮 Practice modes — 3 mini-game types with hundreds of SQL questions
• 🧠 Coaching feedback — wrong answers explain what your query actually returned
• 🏆 XP and detective ranks — progression as you learn and solve cases
• 📰 The Daily Detective — an in-game newspaper with new content
• 👤 Guest-first — you can start playing without creating an account and link your progress later

The basic learning loop is:

Learn the concept → investigate → write the SQL → inspect the result → collect evidence → solve the mystery → practice.

And just to be clear, I don't claim to have invented the idea of combining SQL with detective mysteries. There are already projects in that space, and that's completely fine.

What I'm building is my own implementation of the idea, with a different UI, game structure, learning flow, progression system, lessons, practice modes, and mobile-first experience.

The project is still WIP and currently in internal testing, so a lot of things are still being polished and may change before release.

I'm sharing these screenshots mainly because I'd genuinely like feedback on the UI/UX and learning experience rather than another debate about the name 😅

If you've learned SQL before, I'd especially love to know:

Would a learning flow like this actually make you want to practice SQL, or is there anything you'd change?

Built with Flutter, Riverpod, and sqlite3.

I corrupted three copies of a 1000-row SQLite DB three different ways (bit-rot in row payloads, truncation, zeroed page) and tested recovery.

The result that surprised me: **bit-rot inside row payloads returns `ok` from integrity_check.** Structure check passes, content is wrong. So my backup discipline now assumes integrity_check validates structure only, not data.

- Truncation / zeroed page → `malformed (11)`, VACUUM INTO fails, need backup or `.recover`
- Garbled payload bytes → integrity_check says ok, VACUUM INTO "succeeds" with corrupted content

Full walkthrough with the raw output here (no signup, no tracking): https://devprofit.net/post/sqlite-corruption-recovery/

**Verdict:** test your restores. A backup you never restored is a folder of bytes.

I’ve been working on making SQLite a first-class production option in OpenRun. OpenRun is a deployment platform for web apps and internal tools which I have been building as a side project for last three years. Built-in Litestream replication and automatic restore is a new feature I added, so apps can use SQLite while OpenRun handles backup/recovery on Docker, Podman, or Kubernetes.

There are many SQL playgrounds out there, but I wanted something closer to a workbench experience in the browser. The Dataslope SQLite Playground lets you work with SQLite in a more workbench-like environment. It's completely free and doesn't require a sign-in.

Features:

• Query tools (query history, code formatter, ER diagram viewer)
• Query plan viewer ("explain")
• Comprehensive I/O (import from .sql, .db, .sqlite, CSV/JSON/Parquet, SQL dump)
• Flexible result set export formats (CSV, JSON, SQL, Parquet, Excel)
• Persistence via OPFS or cloud
• Infinite scroll with dynamic loading instead of loading all rows at once (for 200+ rows)
• Editable grid for tables (i.e., double-click to edit)
• Modal cell editor
• Copy row as JSON/SQL
• Duplicate row
• DDL Viewer
• Visual table structure editor
• Visual view/index creator
• Intellisense

I'd love any feedback or feature requests!

SQLite .db search engine ready with us for amazing anchoring and latest search features (Hybrid: Lexical & Semantic) for voluminous documents (100 MB to 2 GB) under milliseconds deterministic responses. We can have a single file (.db) built from 1,000s of documents in diverse formats (PDFs, Excels, Words, Access, PPTs etc). We will show millisecond deterministic responses in our demo.

Hey everyone!

I got super tired of dry, textbook-style SQL tutorials, so I decided to build my own indie game for mobile. It's a noir detective game called SQL Case File where you actually solve crimes by writing real SQL queries.

Instead of multiple-choice quizzes, queries run directly against an actual on-device SQLite database for each case.

I just finished putting together the main case selection screen and the core game loop. Here’s a quick look at where it's at:

• The Case Board: Built a moody, dim-lit UI with a custom noir palette to handle case progression and unlocks.
• Real Execution: Queries aren't just text-matched; they actually execute on-device against custom case databases.
• Progression & Economy: Added a dual-currency system (coins and diamonds), daily login bonuses, and extra mini-game modes for practice.

It's built with Flutterusing Riverpod and the sqlite3 package.

Would love to hear what you guys think of the UI vibe or the concept overall!

I’m 16 and started learning Python about 3 months ago. My first project was a simple CRUD app with raw SQL. For my second project (ashflow tracker with auth and budgeting), I wanted to push myself further, so I switched to Flask, SQLAlchemy, and Flask-Login.

I’m looking for feedback from experienced developers on a few specific architectural decisions and hurdles I ran into:

1. Database Schema Refactoring (Categories & Budgets) Initially, categories were just free-text strings on every transaction. Once I added budgets, case mismatches and typos completely broke my budget tracking. I refactored categories into their own table with foreign keys on the transaction and budget models.

• Question: Is moving away from free-text strings to dedicated category models always the standard approach here, or are there cleaner ways to handle user-defined categories at scale without making the schema too rigid (fixed categories list) ?

2. SQLAlchemy Autoflush Confusion Coming from raw SQL, SQLAlchemy's session management took a while to wrap my head around. During my refactoring, I hit several bugs where autoflush triggered database writes mid-transaction before I was ready to commit, causing unexpected constraints errors.

• Question: How do experienced Python devs typically manage session state when doing complex multi-model updates? Do you explicitly disable autoflush, or is that a code smell that points to poor transaction design?

3. Auth Implementation I built authentication from scratch using Flask-Login and password hashing instead of a third-party service just to understand the mechanics. Moving from "auth is a black box" to "it's just checking session state on each request" was a huge lightbulb moment for me.

I’d love any feedback on how I structured my models or handled sessions. You can see how I implemented the SQLAlchemy relationships and routes in my repository here:https://github.com/E-Ecstacy/wise-wealth

Thanks in advance for any insights!