Category: Uncategorized

Posted on

Movie Finder: semantic search over 1M films, inside MySQL

https://askdba.net/wp-content/uploads/2026/10/myvector_movies-Large.jpeg

Type “a heist that goes wrong in a snowy town” and get back real films, with posters, in a few milliseconds. The vector search behind it runs inside MySQL, with no separate vector database.

Movie Finder is the new demo app that ships with MyVector. It searches up to 1,035,695 TMDB movies by meaning, not keywords. One docker compose up gives you the whole thing: MySQL 9.7 with the MyVector component, a loader, and a small web app.

Try it live: https://demo.myvector.online/

We built it to answer the questions people ask us most. Does vector search in MySQL hold up at a million rows? Can I mix it with ordinary WHERE filters? What happens when I insert a new row? The demo shows the answers on the page, with the SQL that ran under every result.

Live: What you can do on the page

Every feature on the page maps to a MyVector capability, and every result panel shows its SQL.

  • Describe a movie in your own words and get the nearest films. Ask for “a boy wizard at a school of magic” and Harry Potter comes back first.
  • Filter by genre, year, rating and language. These are plain SQL predicates combined with the vector search, and the page tells you which filtered-search path ran and why.
  • Rank by similarity alone, or with a small boost for films many people have rated, so the famous match beats an obscure one at almost the same distance. Both are ordinary ORDER BY expressions.
  • More like this: a film’s stored vector becomes the next query, in pure SQL.
  • HNSW vs exact: run both side by side and compare speed and recall.
  • Add a movie: a plain INSERT, searchable within about a second, with no index rebuild. (Not on live demo)
  • Under the hood: live index details from myvector_index_status, a bar showing where each query’s time went, and a speed-vs-recall chart that sweeps ef_search from 10 to 640 against an exact scan.

How it works

The app embeds only your query text; every movie’s vector already sits in MySQL, so a search is one SQL round trip. The movie vectors come with the dataset, made by nomic-embed-text-v1.5 from each film’s title, tagline, and overview. The app uses the same model locally on the CPU, so there is no API key, and nothing leaves your machine.

New rows need no rebuild. Adding a movie is a plain INSERT; MyVector’s binlog listener picks it up and adds it to the HNSW index, usually within a second.

The SQL

The whole index is declared in a column comment. This is the movies table’s vector column:

embedding VARBINARY(3080) COMMENT
  'MYVECTOR COLUMN type=HNSW,dim=768,size=...,M=16,ef=100,dist=Cosine,online=Y,idcol=id,threads=N'

The loader inserts the rows, then builds the HNSW index with one call:

CALL mysql.myvector_index_build('movies.movies.embedding', 'id');

A search turns the query vector into a nearest-first list of ids with myvector_ann_set(), then joins back to the table. JSON_TABLE keeps the order:

SELECT m.title, myvector_distance(m.embedding, @q, 'Cosine') AS distance
FROM (SELECT myvector_ann_set('movies.movies.embedding', 'id', @q,
                              'nn=10,ef_search=100') AS js) src,
     JSON_TABLE(src.js, '$[*]' COLUMNS (rank_no FOR ORDINALITY, id INT PATH '$')) nn
JOIN movies.movies m ON m.id = nn.id
ORDER BY nn.rank_no;

“More like this” needs no embedding at all. It reads a film’s stored vector into the query variable:

SELECT embedding INTO @q FROM movies.movies WHERE id = @movie_id;

Filters pick one of two paths. The app counts each filter on its own index and takes the smallest count as an upper bound:

  • 50,000 matches or fewer: it passes the matching keys as the fifth argument of myvector_ann_set, so HNSW searches only among them.
  • More than that: it calls MYVECTOR_ANN_FILTERED, which takes the nearest candidates and keeps those that pass the filter.

Run it yourself

To run your own copy, from a clone of the repository:

cd examples/movie-finder
MOVIES=100k docker compose up      # then open http://localhost:8080

The first start downloads the TMDB data, about 7 GB, once. MOVIES picks how many films to load, most-voted first: 10k, 100k (the default) or full. Measured on a 16-core Arm (Neoverse-N1) Linux host with MySQL 9.7.2:

Step 10k 100k full (1,035,695)
Insert 7 s 41 s 407 s
Build the HNSW index (16 threads) 29 s 33 s 545 s
HNSW search 3–5 ms 4–7 ms 5–20 ms
Exact search (scans every row) 30 ms 280 ms 3 s warm
Recall@10, HNSW vs exact 100% 100% 100%

At a million movies, HNSW answers in 5–20 ms where a full scan takes 3 seconds, with the same top 10. Recall is for the unfiltered test query; a broad genre filter (Drama) at full size gave 80% at ef_search 100, and the page lets you raise ef_search to trade time for recall. For the full profile, give Docker about 12 GB of memory and set MYSQL_BUFFER_POOL=6G.

Running it on a remote server? The page and MySQL listen on localhost only. Forward the port instead of opening it: ssh -N -L 8080:127.0.0.1:8080 <server>.

Version note: the demo uses features newer than the v1.26.9 images: filtered search, MYVECTOR_ANN_FILTERED, per-query ef_search, and online updates that survive a restart. Until the next release ships, the README shows how to build a local image from main.

Data: the movie metadata and posters come from TMDB via a Hugging Face mirror. Your machine downloads it; it is not in the repository or any image. This is a non-commercial demo, not endorsed by TMDB.

Try it and tell us

Try the live demo first. To run your own, start with MOVIES=10k for a quick first look, then go to full to watch a million rows answer in milliseconds. The demo guide has screenshots and the other demos; the Movie Finder README has the full details.

If a query surprises you, or you want a feature the page doesn’t show yet, open an issue on GitHub. A star helps other MySQL users find the project.

Planet MySQL

Posted on

Long-Time Slashdot Reader Announces New Open Source Web Browser ‘Northstar’

Long-time Slashdot reader Andreas(R) announces Northstar, a "minimalist" web browser written entirely from scratch in C — now available in version 1.0.11:
One window, one page, one process — about 160,000 lines of original C, small enough for one person to read and audit end-to-end. It carries no upstream browser engine: no Gecko, no WebKit, no Blink. It is free software under the GNU General Public License, version 3 or later, and it runs on Linux, macOS and Windows… Compliance is not inherited from an upstream engine; it is measured, section by section, against the specification text… Private by construction. No telemetry, no update pings, and no AI assistant or AI-style web APIs. Safe browsing checks a top-level navigation’s host against a local SHA-256 blocklist before it is fetched — the check never leaves your machine. Cookies, storage and the cache are partitioned by origin. It’s logo reminds me of the old Netscape logo. (And I love the "Best viewed in…" GIF at the upper-right of its web site.)


Read more of this story at Slashdot.

Slashdot

Posted on

Someone got Doom in an SQL database

https://cdn.arstechnica.net/wp-content/uploads/2026/10/doomsql-1152×648-1790974550.png

“Rendering Doom in a database is obviously a bad idea,” Lukas Vogel writes in a lengthy blog post explaining how exactly he managed to render Doom using an SQL database.

OK, that’s not entirely accurate. The SQLDoom project uses a small Python client to handle input and output, drive the game’s timing, and display each frame to the screen. Behind that, a series of CedarDB tables tracks the game geometry and state, while about 1,300 lines of SQL queries spread across 89 common table expressions implement the game logic and generate 35 bitmap framebuffers per second.

In this, SQLDoom is a major improvement over Vogel’s previous DoomQL project, which last year set out to build “a multiplayer Doom-like shooter entirely in SQL.” Unfortunately, that effort ended up with raycasting-based, grayscale ASCII graphics that were more akin to the simplistic 90-degree-angled maps of Wolfenstein 3D. The newer SQLDoom, on the other hand, generates full-color 640×480 frames that look like they could have come from the original Doom executable.

It’s all just data, man

Converting Doom‘s classic WAD files to a relational database was relatively simple and straightforward, Vogel writes, because of the way the original game broke levels down into vertices, lines, sectors, and so on. Even Doom‘s famous binary-space partition trees can be broken down into SQL using a sort_key for objects that’s pre-computed for each position at load time. With this set in your table, a simple “ORDER BY” statement can determine which parts of walls to display and which to ignore every frame, vastly improving performance.

Ars Technica – All content

Posted on

What’s new in dbForge 2026.2: New PostgreSQL Debugger, visual editors, broader context for AI Assistant, and much more

https://www.devart.com/blog/wp-content/uploads/2026/08/dbforge-2026-2-release.jpg

Here comes dbForge 2026.2, a new release of our ever-evolving ecosystem of AI-powered database lifecycle management solutions—and it’s packed with useful updates you definitely shouldn’t miss! These include a brand-new embedded PostgreSQL Debugger in dbForge Studio, handy visual object editors for PostgreSQL, broader context awareness in dbForge AI Assistant, enhanced SQL development and schema comparison capabilities, and a new, simplified product activation flow. It’s all here to make the daily work of developers, architects, and analysts much easier.

Without further ado, let’s get started!

What’s in the box?

Embedded PostgreSQL Debugger in dbForge Studio

First and foremost, we’re glad to introduce a brand-new PostgreSQL Debugger in dbForge Studio. With its help, you will no longer need to scrutinize your code in order to find potential performance bottlenecks and other possible issues. The Debugger will help you do the following:

  • Set breakpoints in your code to pause the execution at specific lines
  • Step through code line by line to see how each line is executed
  • Monitor the current values of variables, expressions, and query results to analyze how data changes during the execution process
  • Handle exceptions by highlighting the exact line where the error occurs

One of the best things about our new PostgreSQL Debugger is that it’s integrated into dbForge Studio, so you won’t have to deal with any extensions or manual setups at all.

New visual object editors for PostgreSQL

The same dbForge Studio for PostgreSQL has received new visual object editors for event triggers, functions, and procedures. These editors eliminate the need to manage these objects with raw code, bringing the convenience of a visual interface into your daily operations.

You can invoke them in multiple ways:

  • On the Start Page, go to the Database Design tab > New Database Object
  • Go to the Database menu > New Database Object
  • Click the New Database Object icon on the application toolbar
  • In Database Explorer, double-click the required object to open it in the editor
  • In Database Explorer, create a new event trigger/function or open the existing one from the context menu

This is what the editor looks like for event triggers.

This is what the editor looks like for functions.

This is what the editor looks like for procedures.

Also note that dbForge Studio for PostgreSQL now lets you configure the default action performed when you double-click database objects in Database Explorer. Separate default actions can be set for tables and views, and for procedures and functions. You can do it in Tools > Options.

Broader context awareness in dbForge AI Assistant

Another key goal of this release was to make dbForge AI Assistant smarter and more flexible than ever, allowing you to tailor it to your workflows and standards as precisely as possible. To achieve this, your control over the context has been greatly expanded, most notably with the ability to attach files. For instance:

  • You can freely select to auto-attach your currently active document to the AI chat
  • You can attach ready-made files instead of manually copying SQL code into your prompts
  • You can provide the Assistant with sample code to help it learn your coding style and standards—and thus generate code that consistently adheres to them
  • You can attach two scripted databases and have the Assistant compare them
  • You can attach multiple databases to the same chat
  • Generally, you can give the Assistant any files (e.g., application code, database projects/diagrams, or custom instructions) as an additional source of context

Another useful addition to the AI Assistant is the ability to select an AI model to be used. Now you can configure it from the Tools menu > Options > AI Assistant > General. The available models include the following:

  • Anthropic: Claude Haiku 4.5, Claude Sonnet 4.6, Claude Sonnet 5
  • OpenAI: GPT-5.4, GPT-5.5

Free Express edition of dbForge AI Assistant

This release makes dbForge AI Assistant even more accessible by introducing a long-awaited free Express edition. It provides a limited number of tokens and 14-day storage of chat history, which is still a great way to explore the Assistant’s capabilities and try it out in your daily work.

In case you need more extensive AI assistance, with a considerably larger token allowance and unlimited chat history, you can upgrade to a paid plan at any moment.

SQL development enhancements

From now on, you can apply object and column name qualification to code that is already written. Previously, the qualification settings in Options > Text Editor > Code Completion > Advanced applied only while you typed. Now, the new refactoring command uses the same settings and qualifies names in an entire pre-written SQL document or a selected fragment of code.

We have also implemented wildcard expansion for all supported contexts, whether in the entire SQL document or in a selected fragment of code.

These enhancements have been implemented in dbForge SQL Complete and three dbForge Studios: for SQL Server, MySQL, and Oracle. And if you’re dealing with multiple database systems on different projects, you may want to try dbForge Edge, a suite of four Studios that works across a huge number of databases and cloud services.

Quick data generation from Database Explorer

If you need to generate data for a table (or several tables) quickly, just go to Database Explorer, right-click the required table(s), and select Generate Data from the shortcut menu. You will immediately proceed to configure your generation without any unnecessary steps.

New “Last modified” column in schema comparison documents and reports

Schema comparison documents, as well as all three types of comparison reports, now include a handy Last modified column.

This feature has been implemented across dbForge for SQL Server and dbForge for Oracle.

Support for MySQL 26.7 and MariaDB 13.x

Finally, all dbForge tools for MySQL are now seamlessly compatible with MySQL 26.7 and MariaDB 13.x.

Get your dbForge 2026.2 update today!

The update is already available, so you can open your dbForge product, proceed to Help > Check for Updates, and get your dbForge 2026.2 right away.

If you’re not a user of dbForge yet, we gladly invite you to download any product for a free trial and give it a go in your daily work.

For extra convenience, we have introduced product activation via a simple sign-in, now available alongside the traditional methods: entering an activation key and generating an activation request.

And, like we said previously, if you’re dealing with multiple database systems on different projects, you can try dbForge Edge, an AI-powered multidatabase solution that helps you cover the entire database lifecycle—including database design, development, management, and administration—across SQL Server, MySQL, MariaDB, Oracle, PostgreSQL, and a vast number of related database systems and cloud services.

Planet for the MySQL Community

Posted on

Chart of Accounts Professional-grade, production-ready & double-entry Accounting module for Laravel

https://opengraph.githubassets.com/5f86d273fb5ea7c4aba684c9b835365d2cdc94c88444cbf16125197728d92098/alimarchal/laravel-chart-of-accounts-package

Laravel Chart of Accounts

Latest Version on Packagist
Total Downloads
License
PHP Version

Professional-grade, production-ready Chart of Accounts and double-entry Accounting module for Laravel.
One-command install. Works with Jetstream (Blade/Livewire) and Breeze (Inertia/React).

Author: Ali Raza Marchal — kh.marchal@gmail.com
Package: alimarchal/laravel-chart-of-accounts
Source: github.com/alimarchal/laravel-chart-of-accounts-package

Dimension Score Notes
Architecture 9.5/10 Clean service-layer, Actions pattern, no God classes
Double-Entry Correctness 10/10 Balance enforced at DB and application layer + UI
API Coverage 9/10 Full versioned REST API with Eloquent resources
Frontend Flexibility 10/10 Dual-stack: one env switch (ACCOUNTING_UI_DRIVER)
Reporting Depth 9/10 10 financial reports covering all standard statements
Security 9/10 Spatie Permission RBAC, route middleware, @can guards
Developer Experience 9.5/10 One-command install, JournalEntry::record() helper, Select2 UI
Test Coverage 8/10 Feature tests for posting, reversals, voids, edge cases
Documentation 9.5/10 Full README, CHANGELOG, PHPDoc, API examples
  • PHP ^8.2
  • Laravel ^10.0 | ^11.0 | ^12.0 | ^13.0
composer require alimarchal/laravel-chart-of-accounts

Blade/Livewire apps (Jetstream): add ACCOUNTING_UI_DRIVER=blade to .env before installing.
Inertia/React apps (Breeze): leave default (inertia).

php artisan accounting:install

accounting:install does automatically (11 steps):

  1. Publishes accounting migrations
  2. Publishes accounting config (config/accounting.php)
  3. Publishes Blade views (resources/views/vendor/accounting/)
  4. Publishes public assets — jQuery 3.5.1 + Select2 4.1.0 → public/vendor/accounting/
  5. Publishes spatie/laravel-permission migrations (if not present)
  6. Publishes spatie/laravel-activitylog migrations (if not present)
  7. Runs php artisan migrate
  8. Seeds all master data (account types, currencies, COA, permissions, tax codes, periods)
  9. Syncs database objects (stored procedures, views, triggers)
  10. Assigns super-admin role to first user
  11. Verifies the installation

After install — add HasRoles to your User model:

use Spatie\Permission\Traits\HasRoles;

class User extends Authenticatable
{
    use HasRoles;
}

Available roles: super-admin (all), admin, accountant, viewer.

After composer update alimarchal/laravel-chart-of-accounts:

php artisan accounting:update

Re-publishes views, assets, config, JS; runs new migrations; syncs DB objects.

By default the package uses the /accounting/ URL prefix. To change it:

# .env
ACCOUNTING_ROUTE_PREFIX=settings        # URLs: /settings/journal-entries, /settings/reports/...
ACCOUNTING_ROUTE_NAME_PREFIX=accounting # Route names stay: accounting.dashboard, accounting.journal-entries.index

Route names stay as accounting.* regardless of the URL prefix, so views and redirects work without changes.

Settings-style routes example (used in our demo):

URL Route Name
/settings accounting.dashboard
/settings/journal-entries accounting.journal-entries.index
/settings/reports/general-ledger accounting.reports.general-ledger
/settings/chart-of-accounts accounting.chart-of-accounts.index
/settings/periods accounting.periods.index
/settings/users settings.users.index
/settings/roles settings.roles.index
/settings/permissions settings.permissions.index

Creating Journal Entries — Three Ways

1. Static Helper — JournalEntry::record()

The fastest way to create a balanced GL entry programmatically:

use Alimarchal\LaravelChartOfAccounts\Models\JournalEntry;

// Create a draft entry
$entry = JournalEntry::record(
    description: 'Office rent payment',
    debitAccountCode: '5101',   // Rent Expense
    creditAccountCode: '1101',  // Cash
    amount: 150000,
    post: false,                // save as draft
);

// Create and post immediately
$entry = JournalEntry::record(
    description: 'Salary payment — June 2026',
    debitAccountCode: '6101',   // Salaries Expense
    creditAccountCode: '1101',  // Cash
    amount: 500000,
    post: true,                 // post immediately
    reference: 'SAL-2026-06',
);

echo $entry->status;      // 'posted'
echo $entry->reference;   // 'SAL-2026-06'
echo $entry->id;          // auto-assigned ID

Parameters:

Parameter Type Required Description
description string Yes Human-readable transaction description
debitAccountCode string Yes Account code for the debit line (e.g. '6101')
creditAccountCode string Yes Account code for the credit line (e.g. '1101')
amount float Yes Amount — same value debited AND credited
post bool No true = post immediately, false = draft (default)
reference string|null No Optional voucher/invoice reference number

What it does automatically:

  • Resolves account codes to IDs via ChartOfAccount
  • Finds active base currency
  • Finds currently open accounting period
  • Creates entry header + two perfectly balanced lines
  • Optionally posts via JournalEntryService::post()
  • Wraps in a DB transaction

Returns: Fresh JournalEntry model.
Throws: ModelNotFoundException if account code or open period not found.

Create a draft entry:

POST /api/accounting/v1/journal-entries
Authorization: Bearer {token}
Content-Type: application/json

{
  "entry_date": "2026-06-04",
  "accounting_period_id": 1,
  "currency_id": 1,
  "fx_rate_to_base": 1,
  "reference": "SAL-2026-06",
  "description": "Salary payment June 2026",
  "lines": [
    { "chart_of_account_id": 42, "debit": 500000, "credit": 0, "description": "Salaries Expense" },
    { "chart_of_account_id": 11, "debit": 0, "credit": 500000, "description": "Cash" }
  ]
}

Post entry:

POST /api/accounting/v1/journal-entries/{id}/post
Authorization: Bearer {token}

Reverse entry:

POST /api/accounting/v1/journal-entries/{id}/reverse
Authorization: Bearer {token}
Content-Type: application/json

{ "description": "Reversal of SAL-2026-06" }

Void entry:

POST /api/accounting/v1/journal-entries/{id}/void
Authorization: Bearer {token}

List with filters:

GET /api/accounting/v1/journal-entries?filter[status]=posted&filter[entry_date_from]=2026-06-01&sort=-entry_date

3. Web UI (Blade/Livewire)

Visit /settings/journal-entries/create (or /accounting/journal-entries/create).

UI features:

  • All account and cost center dropdowns use Select2 with search
  • Real-time balance status badge (green = balanced, red = not balanced)
  • Save Draft button is disabled until debits = credits — prevents unbalanced saves
  • Live debit/credit totals update as you type

Base URL: /api/accounting/v1

Method Endpoint Description
GET/POST /account-types List / Create
GET/PUT/DELETE /account-types/{id} Show / Update / Delete
GET/POST /chart-of-accounts List / Create
GET/PUT/DELETE /chart-of-accounts/{id} Show / Update / Delete
GET/POST /currencies List / Create
GET /accounting-periods List periods
GET/POST /journal-entries List / Create
GET /journal-entries/{id} Show with lines
PUT /journal-entries/{id} Update draft
POST /journal-entries/{id}/post Post draft
POST /journal-entries/{id}/void Void
POST /journal-entries/{id}/reverse Reverse
GET/POST /reconciliations List / Create
GET /bank-accounts List
GET /cost-centers List
GET /tax-codes List
GET /tax-rates List
GET /account-balance-snapshots Period-end snapshots

All list endpoints support ?filter[field]=value, ?sort=field, ?page=N.

php artisan vendor:publish --tag=accounting-config
// config/accounting.php
return [
    'ui_driver'              => env('ACCOUNTING_UI_DRIVER', 'inertia'),   // 'inertia' or 'blade'
    'route_prefix'           => env('ACCOUNTING_ROUTE_PREFIX', 'accounting'),
    'route_name_prefix'      => env('ACCOUNTING_ROUTE_NAME_PREFIX', 'accounting'),
    'settings_route_prefix'  => env('SETTINGS_ROUTE_PREFIX', 'settings'),
    'api_prefix'             => env('ACCOUNTING_API_PREFIX', 'api/v1/accounting'),
    'middleware'             => ['web', 'auth'],
    'use_permissions'        => true,
    'defaults' => [
        'currency_code'                     => env('ACCOUNTING_BASE_CURRENCY', 'PKR'),
        'cash_account_code'                 => env('ACCOUNTING_CASH_ACCOUNT_CODE', '1101'),
        'bank_account_code'                 => env('ACCOUNTING_BANK_ACCOUNT_CODE', '1102'),
        'retained_earnings_account_code'    => env('ACCOUNTING_RETAINED_EARNINGS_ACCOUNT_CODE', '3101'),
        'rounding_account_code'             => env('ACCOUNTING_ROUNDING_ACCOUNT_CODE', '5201'),
    ],
];
Command Description
accounting:install Full setup: publish all assets, migrate, seed, sync, verify
accounting:update Re-publish assets + sync DB after package upgrade
accounting:seed Seed account types, currencies, COA, permissions, periods
accounting:sync-db-objects Sync database views, triggers, stored procedures
accounting:verify Verify accounting data integrity
accounting:health-check Run accounting health checks
accounting:rebuild-snapshots Rebuild account balance snapshots
accounting:close-fiscal-year Close the current fiscal year
accounting:close-period Close the current accounting period
accounting:open-period Open a new accounting period
Model Table Description
AccountType accounting_account_types Asset, Liability, Equity, Revenue, Expense
ChartOfAccount accounting_chart_of_accounts Hierarchical account tree
Currency accounting_currencies Currencies and exchange rates
AccountingPeriod accounting_periods Fiscal periods with open/close state
JournalEntry accounting_journal_entries Entry header (draft/posted/void/reversed)
JournalEntryLine accounting_journal_entry_lines Debit/credit lines
BankAccount accounting_bank_accounts Bank account register
Reconciliation accounting_reconciliations Bank reconciliation records
TaxCode accounting_tax_codes Tax code definitions
TaxRate accounting_tax_rates Tax rates per code
AccountingAuditLog accounting_audit_logs Full change audit trail
AccountBalanceSnapshot accounting_account_balance_snapshots Period-end snapshots
CostCenter accounting_cost_centers Departmental cost centers
Permission Description
accounting.view View all accounting screens
accounting.manage-settings Manage roles, users, periods
account-types.view/create/update/delete Account type CRUD
currencies.view/create/update/delete Currency CRUD
periods.view/create/update/delete/close/reopen Period management
chart-of-accounts.view/create/update/delete COA CRUD
cost-centers.view/create/update/delete Cost center CRUD
journal-entries.view/create/update/delete/post/reverse/void Journal entry workflow
bank-accounts.view/create/update/delete Bank account CRUD
reconciliations.view/create/update/delete Reconciliation CRUD
tax-codes.view/create/update/delete Tax code CRUD
tax-rates.view/create/update/delete Tax rate CRUD
account-balance-snapshots.view View balance snapshots
reports.*.view View individual reports (GL, TB, BS, IS, CF, AR, AP, BB, CB, AB)
audit-logs.view View audit trail
user.view/create/update/delete/assign-role/assign-permission User management

Roles: super-admin (all), admin, accountant, viewer.

All <select> elements use Select2 4.1.0 served from public/vendor/accounting/:

public/vendor/accounting/jquery.min.js       — jQuery 3.5.1
public/vendor/accounting/select2.min.js      — Select2 4.1.0
public/vendor/accounting/select2.min.css     — Select2 CSS

Falls back to CDN if assets not published.

Journal entry line dropdowns use Select2 with full Livewire compatibility:

  • Destroyed and re-initialized on every livewire:updated event
  • Native change event fired after Select2 selection to sync with Livewire state

To re-publish:

php artisan vendor:publish --tag=accounting-assets --force
Status Description
Draft Editable, not in balances
Posted Locked, balances updated, period must be open
Reversed Counter-entry with swapped debits/credits (GAAP method)
Voided Cancelled without counter-entry

Balance is enforced at three layers:

  1. UI — Save button disabled until balanced; real-time status badge
  2. Application — save() rejects if |debits − credits| ≥ 0.01
  3. Service — JournalEntryService::post() validates before posting

Q: How do I change the URL from /accounting/ to /settings/?
A: Add ACCOUNTING_ROUTE_PREFIX=settings to .env. Route names stay accounting.* so no view changes needed.

Q: Does this work with Jetstream (Livewire)?
A: Yes. Set ACCOUNTING_UI_DRIVER=blade in .env before accounting:install.

Q: How do I update after a package upgrade?
A: Run php artisan accounting:update.

Q: Can I create GL entries without the UI?
A: Yes — use JournalEntry::record(description, debitCode, creditCode, amount, post: true).

Q: Why is the Save button disabled?
A: Debits and credits must be equal before saving. Enter matching amounts in the debit/credit columns.

Q: What is accounting:update?
A: Re-publishes views, assets, config with --force, runs new migrations, syncs DB objects. Run after every composer update.

See CHANGELOG.md for full version history.

MIT — see LICENSE.

laravel accounting · laravel chart of accounts · laravel double-entry bookkeeping ·
laravel journal entries · laravel general ledger · laravel trial balance ·
laravel balance sheet · laravel income statement · laravel cash flow ·
laravel bank reconciliation · laravel ERP · laravel GAAP · laravel IFRS ·
double entry bookkeeping php · accounting package for laravel · laravel COA ·
laravel multi-currency · laravel financial reports · laravel accounting module

Laravel News Links