DEV Community: yoosef alipour

I built an AI context engine in Rust that cuts token bills by 99.6% (using Slime Mold algorithms)

yoosef alipour — Sat, 22 Aug 2026 14:19:18 +0000

TL;DR

Modern AI coding assistants (Cursor, Claude Code, Windsurf, Cline) often dump 30,000+ to 120,000+ raw tokens per instruction, causing high latency, attention degradation ("Lost in the Middle"), and substantial API costs ($75+ per 1,000 requests).

We built NeuroMesh—a native Rust runtime and Model Context Protocol (MCP) server that applies biological routing (Physarum Polycephalum slime mold algorithms) and Genetic AST Slicing to reduce context size by 99.6% (from 25,000 raw tokens down to 96 tokens) while achieving a 100% Pass@1 rate.

pinoox / neuromesh

The Biomimetic Context Engine & Neural Runtime for AI Coding Assistants

🌿 NeuroMesh v0.2.7

The Biomimetic Context Engine & Neural Runtime for AI Coding Assistants

"Do not delete context. Deactivate it. Do not repeatedly rediscover the project. Learn it."

Quick Start • Features • Architecture • MCP Tools • Benchmarks • Web UI

💡 What is NeuroMesh?

NeuroMesh is a local-first, high-performance neural context runtime written natively in Rust. Operating as a Model Context Protocol (MCP) server with an embedded 3D/2D Web UI Monitor Dashboard, NeuroMesh solves context saturation and token bloat for modern AI coding tools (Cursor, Claude Desktop, Windsurf, VS Code, Roo Code, Continue.dev, Zed, Aider, Hermes).

Instead of blindly dumping thousands of lines of raw files into an LLM's context window—causing the notorious Lost in the Middle attention degradation, high latency, and massive token bills—NeuroMesh applies nature-inspired biomimetic algorithms to extract and deliver hyper-lean, 100% sound AST subgraphs with reversible code folds.

📑

…

View on GitHub

The Problem: The Cost and Degradation of Naive Context Injection

Most modern AI coding tools rely on naive context retrieval: when a task is received, dozens of entire source files are read from disk and concatenated directly into the LLM prompt.

flowchart LR
    subgraph Traditional["Traditional Context Injection"]
        direction TB
        B1["User Task"] --> B2["Inject Raw Files (25k+ Tokens)"] --> B3["Attention Degradation & $75/1k Bills"]
    end

    subgraph NeuroMesh["NeuroMesh Biomimetic Engine"]
        direction TB
        G1["User Task"] --> G2["Physarum Routing & Genetic AST Slicing"] --> G3["Lean Context (96 Tokens) & 100% Pass@1"]
    end

This brute-force strategy introduces three technical problems:

Attention Degradation (Lost in the Middle): As context windows expand with irrelevant boilerplate, LLM attention mechanisms lose track of subtle domain constraints and variable declarations, increasing hallucination rates.
Prefill Latency Penalty: Transmitting and processing tens of thousands of unneeded tokens introduces a 3 to 5-second Time-To-First-Token (TTFT) delay on every prompt.
Compounding API Costs: At current frontier model pricing ($3.00/1M input tokens), naive context injection costs ~$75.00 per 1,000 requests. For an engineering team running hundreds of daily queries, this translates to thousands of dollars in wasted context tokens.

"Do not delete context. Deactivate it. Do not repeatedly rediscover the project. Learn it."

The Architecture: Nature-Inspired Context Runtime

Biological systems solved information routing and signal filtering with extreme energy efficiency millions of years ago. NeuroMesh translates five biological mechanisms into a local-first, native Rust architecture:

flowchart TD
    Prompt["Task Intent / User Prompt"] --> TaskSig["1. Intent & Task Signature Extractor"]
    TaskSig --> Physarum["2. Physarum Polycephalum Solver<br/>(Minimal Steiner Subgraph Discovery)"]
    Physarum --> Hebb["3. Synaptic Hebbian STDP Plasticity<br/>(Reinforce Active Co-Access Edges)"]
    Hebb --> Slicer["4. Bio-Genetic Code Slicing<br/>(Exon Preservation & Intron Folding)"]
    Slicer --> Membrane["5. Cellular Osmotic Gate Membrane<br/>(Dynamic Permeability & Risk Tuning)"]
    Membrane --> Output["6. Minimal Reversible Context View"]

1. Physarum Polycephalum (Slime Mold) Routing

Physarum polycephalum is a single-celled organism capable of solving optimal Steiner network problems without centralized control.

NeuroMesh models codebase symbols (functions, types, imports, call-graphs) as tubular network channels. When a user requests a change, the engine simulates Hagen-Poiseuille cytoplasmic fluid flux:

$$Q_{ij} = \frac{D_{ij}}{L_{ij}}(p_i - p_j)$$

Channels with high informational flux dilate, while inactive branches atrophy. This allows the solver to isolate the exact minimal Steiner subgraph connecting seed symbols in local RAM in <25 ms.

2. Genetic Code Slicing (Exons vs. Introns)

In molecular biology, exons are the coding sequences expressed in proteins, while non-coding introns are spliced out.

Using embedded Tree-Sitter parsers in Rust, NeuroMesh splits files into:

Exons: Active target functions, critical type signatures, imported interfaces, and invariants.
Introns: Inactive implementations folded into single-line reversible markers.

// Active target method remains fully unfolded:
const renderCart = () => {
  const items = document.querySelector("[data-cart-items]");
  const totalEl = document.querySelector("[data-cart-total]");
  /* [neuromesh:fold:fold_if_3 | 7 lines folded | if (!items || !totalEl) return;] */
  document.querySelectorAll("[data-cart-count]").forEach((el) => (el.textContent = count));
  totalEl.textContent = money(total);
  // ... active cart logic
};

// Untargeted functions are safely folded into reversible markers:
/* [neuromesh:fold:fold_slider_17 | 14 lines folded | if (!root) return;] */
/* [neuromesh:fold:fold_anim_18 | 6 lines folded | stop();] */

Reversible Lazy Context Materialization

If the AI agent requires the full body of a folded block during reasoning, it calls neuromesh_expand_fold via MCP, expanding only that specific fold on demand without re-ingesting the whole project.

3. Synaptic STDP Plasticity (Hebbian Learning)

NeuroMesh maintains an in-memory graph where edges adapt using Spike-Timing-Dependent Plasticity (STDP):

Long-Term Potentiation (LTP): Co-edited files and co-referenced symbols strengthen their synaptic conductance ($w_{ij} \leftarrow w_{ij} + \Delta w$).
Long-Term Depression (LTD): Distracting or unreferenced paths decay over time, making future context discovery faster and more accurate as development progresses.

4. Mycelial Hyphal Predictive Cache

Modeling symbol access as fungal nutrient gradients, NeuroMesh predicts downstream AST dependencies during keystrokes and pre-warms them in memory before an inference call is initiated.

5. Cellular Membrane Osmotic Quality Gate

Acts as a dynamic biological membrane that regulates context permeability (Hyper-Impermeable AST vs. Fully Permeable bodies) based on task risk tier, code complexity, and token budget constraints.

Empirical Benchmarks

We evaluated NeuroMesh against traditional raw context injection across 24 full-stack codebase files (pricing engines, auth middleware, payment webhooks, database pools):

Benchmark Metric	Traditional Raw Context	NeuroMesh v2.0	Improvement
Average Input Tokens per Task	24,994 tokens	96.8 tokens	99.61% Reduction
Automated Test Pass Rate (Pass@1)	90.0%	100.0% (10/10 Passed)	+10.0% Precision
Local Graph Traversal Latency	N/A	24.4 ms	Sub-50ms Context Delivery
API Cost per 1,000 Prompts (Claude 3.7 / GPT-4.5)	$74.98	$0.29	99.6% Cost Reduction
Resident Memory Footprint (RAM)	N/A	~195 MB	Ultra-lightweight
Concurrent Request Throughput	N/A	20 req in 853 ms	100% Zero-drop Concurrency

Financial ROI Analysis

For an engineering team of 10 developers generating 500 prompts per day on Frontier LLMs:

Traditional Context Cost: (5,000 × 24,994 × $0.000003) × 30 = ~$3,374.19 / month
NeuroMesh Cost: (5,000 × 96.8 × $0.000003) × 30 = ~$13.06 / month
Net Annual Financial Savings: $40,333.56 / year

pie title Monthly API Expenditure (10 Devs / 500 prompts per day)
    "Traditional Raw Context ($3,374 / mo)" : 3374
    "NeuroMesh ($13 / mo)" : 13

Embedded Web UI Monitor

NeuroMesh includes a zero-dependency local dashboard running on http://127.0.0.1:8765:

3D Constellation Explorer: Real-time visual graph of your codebase modules, symbols, and synaptic weights.
Context Flow Simulator: Step-by-step visual inspection of Ingestion, Physarum routing, Hebbian plasticity, and AST slicing.
Telemetry & Health: Live monitoring of token compression ratios, RAM consumption, and query latencies.

# Launch the Web UI Monitor and MCP Server
neuromesh monitor

Quick Start

NeuroMesh is packaged as a single native Rust binary with zero external runtime dependencies.

Installation

macOS & Linux (Bash / Zsh):

curl -fsSL https://raw.githubusercontent.com/pinoox/neuromesh/main/install.sh | bash

Windows (PowerShell):

irm https://raw.githubusercontent.com/pinoox/neuromesh/main/install.ps1 | iex

Cargo (Rust Developers):

cargo install --git https://github.com/pinoox/neuromesh.git neuromesh-cli --bin neuromesh

Universal MCP Configuration

NeuroMesh implements the open Model Context Protocol (MCP) and integrates with major AI coding environments:

Cursor IDE

Add to .cursor/mcp.json (or via Cursor Settings > Features > MCP):

{
  "mcpServers": {
    "neuromesh": {
      "command": "neuromesh",
      "args": ["mcp"]
    }
  }
}

VS Code / GitHub Copilot / Cline / Roo Code

Add to .vscode/mcp.json or cline_mcp_settings.json:

{
  "mcpServers": {
    "neuromesh": {
      "command": "neuromesh",
      "args": ["mcp"]
    }
  }
}

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "neuromesh": {
      "command": "neuromesh",
      "args": ["mcp"]
    }
  }
}

Claude Code CLI

claude mcp add neuromesh -- neuromesh mcp

Windsurf IDE & Zed Editor

Add neuromesh mcp to your respective editor MCP configuration.

Exposed MCP Tools

Once connected, your AI agents gain access to the following native tools:

neuromesh_get_context: Task-driven Physarum Steiner context routing.
neuromesh_get_file_skeleton: Generates AST skeletons with active exons and folded introns.
neuromesh_expand_fold: Reversibly unpacks any folded block on demand.
neuromesh_search_symbols: Fast fuzzy symbol lookup across files, types, and functions.
neuromesh_get_dependencies: Dependency and call-graph tracing.
neuromesh_record_feedback: Updates Hebbian synaptic weights based on code generation success.

Open Source & Roadmap

NeuroMesh is open-source under the MIT License.

GitHub Repository: github.com/pinoox/neuromesh
Architecture Documentation: ARCHITECTURE.md
Empirical Benchmark Report: BENCHMARK.md

Discussion

How are you managing context size and token budgets in your AI-assisted workflows? Have you experimented with AST slicing or graph-based context retrieval? Let's discuss in the comments.

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.

DEV Community: yoosef alipour

I built an AI context engine in Rust that cuts token bills by 99.6% (using Slime Mold algorithms)

TL;DR

pinoox / neuromesh

The Biomimetic Context Engine & Neural Runtime for AI Coding Assistants

🌿 NeuroMesh v0.2.7

The Biomimetic Context Engine & Neural Runtime for AI Coding Assistants

💡 What is NeuroMesh?

📑

The Problem: The Cost and Degradation of Naive Context Injection

The Architecture: Nature-Inspired Context Runtime

1. Physarum Polycephalum (Slime Mold) Routing

2. Genetic Code Slicing (Exons vs. Introns)

Reversible Lazy Context Materialization

3. Synaptic STDP Plasticity (Hebbian Learning)

4. Mycelial Hyphal Predictive Cache

5. Cellular Membrane Osmotic Quality Gate

Empirical Benchmarks

Financial ROI Analysis

Embedded Web UI Monitor

Quick Start

Installation

macOS & Linux (Bash / Zsh):

Windows (PowerShell):

Cargo (Rust Developers):

Universal MCP Configuration

Cursor IDE

VS Code / GitHub Copilot / Cline / Roo Code

Claude Desktop

Claude Code CLI

Windsurf IDE & Zed Editor

Exposed MCP Tools

Open Source & Roadmap

Discussion

DevDB: A Zero-Setup Database for Faster Local Development

Table of Contents

Why DevDB?

What Problems Does DevDB Solve?

Who Is DevDB For?

PHP Developers

Laravel Developers

Open-Source Maintainers

Startups and Small Teams

CLI, Desktop, and AI Tools

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

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

The Idea

Meet Movo

Features

Why Open Source?

Current Status

Try It

Pinion: Resumable File Uploads for PHP

(Without Fighting upload_max_filesize)

What is Pinion?

Why not just use S3?

How it works (30-second version)

Server side: 10 lines of PHP

Browser side: one function, zero extra deps

Level up when you need to

What I like about the design

Real-world fit

Try it

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

Install

What's new in 2.1

1. Laravel integration — first-class

2. 184 language packs with regional variants

3. Smart input formats

4. Fraction reading

5. Year reading

6. Phone number reading

7. Roman numerals

8. IP address and version string reading

9. GitHub Actions CI

(Without Fighting `upload_max_filesize`)