DEV Community: yoosef alipour

DevDB: A Zero-Setup Database for Faster Local Development

yoosef alipour — Thu, 02 Jul 2026 04:53:41 +0000

Starting a new project should be simple.

Clone the repository, install dependencies, run the app, and start building.

But in many PHP projects, developers often need to complete several extra steps before they can even see the first page:

Install MySQL or MariaDB
Start the database service
Create a database manually
Configure usernames, passwords, ports, and environment variables
Run migrations
Troubleshoot connection errors

For production systems, these steps are completely reasonable.

But for local development, prototypes, demos, tests, and open-source projects, they can create unnecessary friction.

That is why DevDB exists.

DevDB is a lightweight database designed to make local development easier. It helps developers start working on a project without installing and configuring a separate database server.

The goal is not to replace MySQL, MariaDB, or PostgreSQL in production.

The goal is to remove friction from development.

Why DevDB?
What Problems Does DevDB Solve?
Who Is DevDB For?
Using DevDB with Laravel
DevDB and the Pinoox Ecosystem
Is DevDB a Replacement for MySQL?
The Real Value: Less Friction
What Could Come Next?
Final Thoughts

Why DevDB?

Every extra setup step makes a project harder to try.

This is especially important for open-source projects, developer tools, starter kits, and frameworks. If someone needs to install PHP, Composer, MySQL, create a database, configure credentials, and edit environment files before running your project, many people may simply stop before they begin.

DevDB reduces that setup overhead.

Instead of asking developers to prepare a full database server, DevDB provides a lightweight local database experience that can work directly with the project.

The result is a simpler workflow:

git clone your-project
composer install
php artisan serve

No MySQL installation.
No manual database creation.
No database credentials.
No port configuration.
No unnecessary setup.

What Problems Does DevDB Solve?

DevDB is especially useful when you need:

Faster local project setup
A database without installing MySQL or MariaDB
Easier onboarding for new developers
A lightweight database for prototypes and demos
Isolated databases for testing
Offline development support
A built-in storage solution for CLI or desktop applications
A simpler developer experience for open-source projects

It is designed for situations where setting up a full database server is unnecessary or slows down development.

Who Is DevDB For?

PHP Developers

If you work with PHP projects and want to avoid setting up MySQL for every new project, DevDB can make your local environment much faster and easier to manage.

Laravel Developers

Laravel already provides excellent tools for database management, including migrations, seeders, factories, and Eloquent ORM.

However, many Laravel projects still require developers to install and configure MySQL, MariaDB, PostgreSQL, Docker, Laravel Sail, or another local database solution before they can start working.

DevDB can simplify that first step.

Instead of requiring a full database server for local development, a Laravel project can use DevDB as a lightweight development database. Developers can clone the project, install dependencies, run migrations, and start building immediately.

git clone your-laravel-project
cd your-laravel-project
composer install
php artisan migrate
php artisan serve

This is especially useful for:

Laravel starter kits
Open-source Laravel packages
Small and medium Laravel applications
Rapid prototypes
Demo projects
Educational projects
Local testing environments
Developer tools built with Laravel

DevDB can work as a development-first database option, while production environments continue using MySQL, MariaDB, or PostgreSQL.

A typical setup could look like this:

# Local development
DB_CONNECTION=devdb

# Production
DB_CONNECTION=mysql

This keeps local development simple while allowing production environments to use a scalable and familiar database infrastructure.

Open-Source Maintainers

A project that is easy to install is more likely to be tested, used, and contributed to.

DevDB can reduce installation steps and make your project more accessible to new contributors.

Startups and Small Teams

Early-stage products need speed.

When your team can start building without spending time on database setup, you can focus more on features, experiments, and product validation.

CLI, Desktop, and AI Tools

Many modern tools need local storage for things like:

Settings
Logs
Project metadata
Local history
Cached data
Agent memory
Generated content

DevDB can provide a lightweight database layer without requiring users to install and manage a separate database server.

Using DevDB with Laravel

DevDB can be especially valuable in Laravel projects where the goal is to provide a simple and fast local development experience.

A Laravel application could include DevDB as a development dependency and configure it automatically during installation.

For example:

composer require pinoox/devdb --dev

Then the project can use a dedicated database connection inside config/database.php:

'devdb' => [
    'driver' => 'devdb',
    'database' => database_path('devdb/database.devdb'),
],

Once configured, developers can continue using familiar Laravel commands:

php artisan migrate
php artisan db:seed
php artisan test

The goal is not to change the Laravel development workflow.

The goal is to make the workflow easier to start.

Developers can still use migrations, seeders, factories, Eloquent models, relationships, and Laravel testing tools. DevDB simply removes the need to install and configure a separate database server for local development.

DevDB and the Pinoox Ecosystem

DevDB is designed to improve the development experience inside the Pinoox ecosystem.

For example, a developer can create a project, run migrations, and start building without first installing MySQL.

pinx new my-app
cd my-app
pinx migrate
pinx dev

This makes the development workflow much more approachable, especially for developers who want to quickly test an application, build a prototype, or contribute to a project.

Instead of spending time configuring infrastructure, developers can focus on writing features.

Is DevDB a Replacement for MySQL?

Not exactly.

DevDB is not intended to replace MySQL, MariaDB, or PostgreSQL in every situation.

For production applications with large datasets, high concurrency, multiple services, replication, advanced monitoring, or complex infrastructure requirements, traditional database servers are still the better choice.

DevDB is best used for:

Local development
Testing
Prototypes
Small internal tools
CLI applications
Desktop applications
Open-source demos
Fast project setup

A practical workflow could look like this:

Environment	Recommended Database
Local Development	DevDB
Automated Testing	DevDB or isolated test database
Production	MySQL, MariaDB, or PostgreSQL

This approach keeps development fast while still allowing production systems to use powerful and scalable database infrastructure.

The Real Value: Less Friction

DevDB is not only about using a lightweight database.

Its real value is improving the developer experience.

When developers can run a project without installing extra services, configuring credentials, or debugging database connections, they can start building much faster.

This improves:

Developer onboarding
Open-source adoption
Prototype speed
Local development workflows
Team productivity
Project accessibility

A good development environment should help developers focus on the product, not on setup.

What Could Come Next?

DevDB can grow beyond a lightweight local database.

Possible future features could include:

A visual database browser
Built-in table and record management
Query execution tools
Migration management
Import and export support
Test database generation
Database snapshots
AI-assisted schema analysis
Easy migration from DevDB to MySQL or PostgreSQL
Integration with desktop and CLI developer tools

These features could turn DevDB into a complete local development database experience.

Final Thoughts

DevDB solves a simple but common problem:

You should not need to install and configure a full database server just to start developing a project.

It is not designed to replace production databases.

It is designed to make development faster, easier, and more accessible.

If you want to reduce setup time, simplify onboarding, create better open-source developer experiences, or build tools that need local storage without extra dependencies, DevDB can be a useful part of your workflow.

Explore DevDB on GitHub:

https://github.com/pinoox/devdb

I Built an Open-Source AI Coding Assistant That Works Like Cursor and Codex — But It's Free

yoosef alipour — Sat, 27 Jun 2026 21:04:28 +0000

AI coding assistants have completely changed how many of us write software.

Today it's normal to ask an AI to:

Build a new feature
Fix bugs
Refactor code
Generate tests
Explain unfamiliar code
Update documentation
Execute project commands

The problem is that most modern AI coding tools come with at least one of these limitations:

They require an account.
They're tied to a specific editor.
Many useful features are locked behind paid plans.
They're not fully open source.

I wanted something simpler.

The Idea

Instead of building another AI chat application, I wanted to create a lightweight desktop tool that behaves like an AI software engineer.

You describe what you want in natural language, and the assistant works directly inside your project.

Examples:

"Create a REST API for authentication."

"Refactor this module using the repository pattern."

"Write unit tests for this service."

"Explain why this function is slow."

"Rename these files and update imports."

The goal is to spend less time switching between tools and more time building software.

Meet Movo

Movo is an open-source desktop AI coding assistant designed for developers.

It focuses on making AI-powered development simple and accessible.

Features

🤖 AI-powered coding assistant
💬 Natural language interface
🐞 Bug fixing
✨ Code generation
♻️ Refactoring
🧪 Test generation
📝 Documentation generation
⚡ Execute project commands
🔌 MCP support
📦 Skills & Rules support
🌍 Windows, macOS and Linux
🔓 Completely open source

Why Open Source?

One of the biggest advantages of open source AI tools is transparency.

Developers can:

Audit the source code
Customize workflows
Add new capabilities
Integrate their own models
Contribute improvements

Instead of being locked into a specific ecosystem, the community can shape the project together.

Current Status

Movo is still in its early stages.

The core experience is already working, but there are many features planned, including:

Better agent workflows
More MCP integrations
Additional Skills
Improved project understanding
More customization options

Feedback from developers will play a huge role in deciding where the project goes next.

Try It

If you'd like to test it, contribute, or simply follow the project, check out the GitHub repository:

https://github.com/movobox/movo

Contributions, ideas, bug reports, and feature requests are always welcome.

If you find the project interesting, consider giving it a ⭐ on GitHub—it really helps open-source projects grow.

Happy coding! 🚀

Pinion: Resumable File Uploads for PHP

yoosef alipour — Wed, 17 Jun 2026 23:34:06 +0000

(Without Fighting `upload_max_filesize`)

You deploy your app. A user picks a 400 MB video. They hit upload. The progress bar freezes. Then — nothing.

You check the logs. POST Content-Length exceeded post_max_size. Again.

We've all been there. The fix is usually "raise PHP limits" or "use S3." Both work — until you're on shared hosting, a legacy VPS, or a client who won't touch php.ini.

That's the problem Pinion solves.

What is Pinion?

Pinion is an open-source resumable chunked upload protocol for PHP.

Instead of one giant multipart/form-data request, the browser sends the file in small parts (default: 5 MB). The server stores each part, then assembles the final file on disk.

Three steps. That's the whole contract:

init → upload parts → complete

Package	Registry	Role
`pinoox/pinion`	Packagist	PHP server engine
`@pinooxhq/pinion-client`	npm	Browser client

Protocol id: pinion · version: 2

Why not just use S3?

Object storage is great. But sometimes you need files on your server:

A CMS media library on local disk
A Laravel app without cloud budget
Shared hosting with no S3 SDK
An admin panel behind a simple PHP API

Pinion isn't a CDN or a storage service. It's a protocol — a stable HTTP contract that works in plain PHP, Laravel, or Pinoox.

How it works (30-second version)

sequenceDiagram
    participant Browser
    participant API
    participant Disk

    Browser->>API: POST /init (filename, size, fingerprint)
    API-->>Browser: upload_id, chunk_size, missing_indexes

    loop Each part
        Browser->>API: POST /upload (chunk + SHA-256 hash)
        API->>Disk: store part
    end

    Browser->>API: POST /complete
    API->>Disk: assemble file
    API-->>Browser: done ✓

Resume is built in. The client sends a fingerprint (name:size:lastModified:type). If the connection drops, the same file picks up where it left off — only missing parts are re-uploaded.

Integrity too. Each part gets a SHA-256 chunk_hash. The server can reject corrupted chunks before they pollute your disk.

Server side: 10 lines of PHP

composer require pinoox/pinion

use Pinoox\Pinion\Pinion;

Pinion::configure(['storage_path' => '/tmp/pinion']);

$handler = Pinion::http(['destination' => 'uploads/videos']);

$handler->init($_POST);
$handler->upload($_POST, $_FILES['chunk'] ?? null);
$handler->complete($_POST);

Wire five routes under any prefix you like:

POST /api/v1/upload/init
POST /api/v1/upload/upload
POST /api/v1/upload/complete
GET  /api/v1/upload/status/{id}
POST /api/v1/upload/abort/{id}

HttpHandler returns plain arrays — map them to JSON in Laravel, Pinoox, or raw PHP. No framework lock-in.

Browser side: one function, zero extra deps

npm install @pinooxhq/pinion-client

import { uploadFile } from '@pinooxhq/pinion-client';

await uploadFile(file, {
  baseURL: '/api/v1/upload',
  unwrapPreset: 'pinoox',
  onProgress: ({ percent, speed, eta }) => {
    console.log(`${percent}% · ${speed} B/s · ETA ${eta}s`);
  },
});

No Axios required. The client uses native fetch by default. Already on Axios? Pass it in — you get per-chunk onUploadProgress too.

baseURL is just the prefix. The client calls /init, /upload, /complete for you. You don't loop over chunks manually unless you want to.

Level up when you need to

Start simple. Grow when the project demands it.

Need	API
One upload button	`uploadFile(file, options)`
Reusable uploader	`pinion({ baseURL }).for(file).upload()`
Batch + cancel + hooks	`createPinionFetch(options)`
Full manual control	`client.api.init()` → `uploadPart()` → `complete()`

Small files? Skip Pinion entirely:

const result = await uploadFile(file, {
  baseURL: '/api/v1/upload',
  auto: true,
  threshold: 8 * 1024 * 1024,
});

if (result === null) {
  // file under 8 MB — use your normal single POST
}

What I like about the design

1. Boring HTTP. JSON for init/complete, FormData for chunks. No WebSockets, no custom binary framing. Debug with curl or DevTools.

2. Parallel by default. Upload 2 parts at once. Retry failed parts with backoff. Progress includes speed and ETA — not just a percentage.

3. Framework adapters, not framework prison. Core engine is pure PHP. Laravel gets a Service Provider and Facade. Pinoox gets a Portal and CLI (pinion:list, pinion:clean). Plain PHP gets HttpHandler.

4. Unwrap presets. Your API returns { data: { … } }? Set unwrapPreset: 'pinoox'. Flat JSON? Use 'flat'. The client adapts; you don't rewrite parsers.

Real-world fit

Scenario	Pinion helps because…
Shared hosting (20 MB cap)	5 MB parts fit under the limit
Mobile / flaky Wi-Fi	Resume after disconnect
Admin upload panels	Progress bar with real bytes + ETA
Video courses / archives	GB-scale without touching `php.ini`
Multi-framework teams	Same protocol, PHP + JS packages

Try it

# Server
composer require pinoox/pinion

# Browser
npm install @pinooxhq/pinion-client

Repo: github.com/pinoox/pinion
PHP docs: README
Client docs: client/README
License: MIT

If you've fought upload_max_filesize one too many times, Pinion might save your next Friday night.

Questions, issues, or war stories welcome in the repo. 🙌

Numera 2.1: Laravel Support, 184 Languages, and a Whole Lot More

yoosef alipour — Mon, 25 May 2026 19:58:19 +0000

A follow-up to Numera: A PHP Library for Number to Words Conversion

When I published the first article about Numera back in 2024, it was a simple library with one goal: convert numbers to words in PHP. The response was encouraging, and the community feedback (including the great note about en vs en-US) pushed me to think bigger.

Today, Numera 2.1 is out — and it's a different beast. Same simple API, but now with 184 language packs, a Laravel bridge, GitHub Actions CI, and a set of new reading modes that cover real-world use cases I kept running into.

Let me walk you through what's new.

Install

# Plain PHP
composer require pinoox/numera:^2.1

# Laravel 9 / 10 / 11
composer require pinoox/numera-laravel

What's new in 2.1

1. Laravel integration — first-class

The most-requested feature. Install pinoox/numera-laravel and you get auto-discovery, a Facade, and a publishable config — nothing to wire up manually.

use Pinoox\Numera\Laravel\Facades\Numera;

echo Numera::n2w(2024);               // two thousand twenty-four
echo Numera::toCurrency(1500, 'USD'); // one thousand, five hundred dollars

Numera::setLocale('fa');
echo Numera::n2w(1500); // هزار و پانصد

Publish the config to set your default locale:

php artisan vendor:publish --tag=numera-config

// config/numera.php
return [
    'default_locale'  => 'en',
    'fallback_locale' => 'en',
];

All public methods work on the Facade — n2w, w2n, toOrdinal, toCurrency, withUnit, toWeekday, translateTo, and all the new ones below.

2. 184 language packs with regional variants

Numera now ships with 184 ISO 639-1 language packs plus regional variants like en-US, en-GB, fa-IR, and de-AT. Regional files only declare overrides; everything else is inherited from the parent locale.

Numera::init('en-GB')->toCurrency(3.01, 'GBP'); // three pounds and one penny
Numera::init('fa-IR')->getWeekdays();            // starts Saturday
Numera::init('de-AT')->getStrategyName();        // german (inherited from de)

Languages with special compounding rules use a strategy system:

Strategy	Locales	Why
`german`	`de`, `de-*`	Inverted tens: einundzwanzig
`french`	`fr`, `fr-*`	Vigesimal 70–99: quatre-vingts
`multiplier_tens`	`id`, `ms`, `vi`, …	2×10+3, not 2+10+3
`default`	Most others	English-style place value

3. Smart input formats

Different regions format numbers differently. Numera now handles them all automatically.

$n = Numera::init('en');

// European format (dot as thousands, comma as decimal)
echo $n->n2w('1.234.567,89');

// Swiss format (apostrophe as thousands)
echo $n->n2w("1'234'567.89");

// Persian/Arabic digits
echo $n->n2w('۱۲۳۴'); // converted to 1234 automatically

// Underscore separator (PHP/Python style)
echo $n->n2w('1_000_000'); // one million

You can also detect the format explicitly:

Numera::detectFormat('1.234,56');   // 'european'
Numera::detectFormat("1'000");      // 'swiss'
Numera::detectFormat('۱۲۳');       // 'persian'
Numera::detectFormat('1_000_000'); // 'underscore'

4. Fraction reading

Common fractions are now read naturally instead of as raw decimals.

$n = Numera::init('en');

echo $n->toFraction(0.5);   // one half
echo $n->toFraction(0.25);  // one quarter
echo $n->toFraction(0.75);  // three quarters
echo $n->toFraction(1.5);   // one and a half
echo $n->toFraction(2.333); // two and one third

// Persian
echo Numera::init('fa')->toFraction(0.5); // نیم
echo Numera::init('fa')->toFraction(1.5); // یک و نیم

Short alias: n2f()

5. Year reading

Years are spoken differently from cardinals — "nineteen ninety-nine", not "one thousand nine hundred ninety-nine".

$n = Numera::init('en');

echo $n->toYear(1999); // nineteen ninety-nine
echo $n->toYear(2000); // two thousand
echo $n->toYear(2005); // two thousand and five
echo $n->toYear(2024); // twenty twenty-four

// Persian falls back to standard cardinal
echo Numera::init('fa')->toYear(1402); // هزار و چهارصد و دو

Short alias: n2y()

6. Phone number reading

Read phone numbers digit-by-digit, preserving the grouping from the input format.

$n = Numera::init('en');

echo $n->toPhone('+1 415 555 0172');
// plus one, four one five, five five five, zero one seven two

echo $n->toPhone('021-8834-1100');
// zero two one, eight eight three four, one one zero zero

// Persian digits work too
echo $n->toPhone('۰۲۱-۸۸۳۴');
// zero two one, eight eight three four

Short alias: n2p()

7. Roman numerals

$n = Numera::init('en');

echo $n->toRoman(2024);   // MMXXIV
echo $n->toRoman(1999);   // MCMXCIX
echo $n->fromRoman('XIV'); // 14
echo $n->fromRoman('xl');  // 40 (case-insensitive)

Range: 1–3999. Throws InvalidArgumentException outside that range.

Short alias: n2r()

8. IP address and version string reading

$n = Numera::init('en');

echo $n->toIp('192.168.1.1');
// one ninety-two dot one sixty-eight dot one dot one

echo $n->toVersion('2.14.0');
// two point fourteen point zero

echo $n->toVersion('1.0.0-beta');
// one point zero point zero dash beta

Short aliases: n2ip(), n2v()

9. GitHub Actions CI

Numera now runs a full test matrix on every push and PR — PHP 8.0, 8.1, 8.2, and 8.3. No more "works on my machine" surprises.

What still carries over from 2.0

Everything from the previous release still works exactly the same:

// Cardinals
Numera::init('en')->n2w(4454545156);
// four billion, four hundred fifty-four million, ...

// Ordinals
Numera::init('en')->n2o(21); // twenty-first
Numera::init('fa')->n2o(21); // بیست و یکم

// Currency
Numera::init('en')->toCurrency(1250.50, 'USD');
// one thousand, two hundred fifty dollars and fifty cents

// Units
Numera::init('en')->withUnit(5, 'hour'); // five hours
Numera::init('fa')->withUnit(1, 'day');  // یک روز

// Weekdays
Numera::init('fa')->toWeekday(6); // شنبه

// Cross-locale translation
Numera::init('fa')->translateTo('en', 'دویست و یک'); // two hundred one
Numera::init('en')->translateTo('fa', 'two hundred one'); // دویست و یک

Real-world use cases

Invoice systems — convert totals to words for legal documents:

echo Numera::init('fa')->toCurrency(15750000, 'IRR');
// پانزده میلیون و هفتصد و پنجاه هزار ریال

Accessibility — read version numbers and IPs aloud in screen-reader friendly text:

echo Numera::init('en')->toVersion('3.2.1'); // three point two point one

Financial reports — ordinals for ranking, fractions for ratios:

echo Numera::init('en')->n2o(1);         // first
echo Numera::init('en')->toFraction(0.5); // one half

Forms and CRMs — read user-entered phone numbers back:

echo Numera::init('en')->toPhone('+44 20 7946 0958');

Numera: A PHP Library for Number to Words Conversion

yoosef alipour — Sun, 28 Apr 2024 08:34:07 +0000

As a developer, you may have encountered situations where you need to convert numbers to words or vice versa. This can be a tedious task, especially when dealing with large numbers or multiple languages. That's where Numera comes in - a powerful PHP library that makes number to words conversion a breeze.

In this article, we'll explore the features and benefits of Numera, and show you how to use it in your PHP projects.

What is Numera?

Numera is a PHP library that provides a simple and efficient way to convert numbers to words and vice versa. It supports multiple languages, including English and Persian, with more languages to come. Numera is designed to be easy to use and extend, making it a great tool for any PHP project.

Features of Numera

Numera has a range of features that make it a powerful tool for number to words conversion. Some of the key features include:

Number to Words Conversion: Convert numbers to words in a variety of languages.
Words to Number Conversion: Convert words to numbers in a variety of languages.
Camel Case Support: Output words in camel case for easier readability.
Multi-Language Support: Supports multiple languages, with more languages to come.
Easy to Use: Simple and intuitive API makes it easy to use Numera in your projects.
Easy to Extend: Numera is designed to be easy to extend, making it simple to add support for new languages.

Install via Composer

You can install Numera using Composer:

composer require pinoox/numera

How to Use Numera

Using Numera is straightforward. Here's an example of how to convert a number to words:

use Pino\Numera;

$numera = Numera::init('en'); // Initialize with English locale
$result = $numera->convertToWords(4454545156);
echo $result; // Output: "four billion, four hundred fifty-four million, five hundred forty-five thousand, one hundred fifty-six"

Converting words to numbers is just as easy:

$result = $numera->convertToNumber('four billion, four hundred fifty-four million, five hundred forty-five thousand, one hundred fifty-six');
echo $result; // Output: 4454545156

Benefits of Using Numera

There are several benefits to using Numera in your PHP projects. Some of the key benefits include:

Saves Time: Numera saves you time and effort by providing a simple and efficient way to convert numbers to words and vice versa.
Improves Readability: Numera's camel case support makes it easy to output words in a readable format.
Multi-Language Support: Numera's support for multiple languages makes it a great tool for international projects.
Easy to Use: Numera's simple and intuitive API makes it easy to use, even for developers with limited experience.

Get Started with Numera

To get started with Numera, head over to the Numera GitHub repository and follow the installation instructions. You can also check out the Numera documentation for more information on how to use Numera in your projects.

Conclusion

Numera is a powerful and flexible PHP library that makes number to words conversion a breeze. With its support for multiple languages, camel case output, and easy-to-use API, Numera is a great tool for any PHP project. Whether you're working on a simple website or a complex application, Numera is definitely worth considering.