Open-source engineering by Amin Abbasi, Türkiye

Where serenity meets speed.

Araminix is the open-source work of Amin Abbasi in one place: zero-crash streaming runtimes, real-time actor platforms, software for power plants and the protocols they speak, and ten years of backend architecture in libraries, studies and starters. Typed end to end, tested at every level and documented like products.

flagship products
4
npm downloads last month
2.6k+
automated tests in the products
1,800+
years building backends
10+

Products

Four products, one standard

Two tools for the people who build and run the grid, and the runtime and protocol underneath real-time applications: each built to the same bar of typing, testing and documentation.

Web app · Energy engineering

plantline

Single-line diagrams and DWG/DXF plant layouts, in the browser.

A free tool for the people who design, build and run power plants. Draw the plant's single-line diagram, open its AutoCAD drawing and see the plant on the map with its tables, inverters, turbines, towers and cables found and counted. No account and no server: drawings are read in the browser and never leave it.

  • A real diagram editor. 23 IEC 60617 symbols, drag and drop, connection points, shaped line routes, group editing, properties for every kind of equipment and design checks; a new diagram starts empty or from a ready example of its plant type.
  • AutoCAD in the browser. DWG and DXF read by a .NET reader compiled ahead of time to WebAssembly: a 7.5 MB plant with 27,000 block copies opens in about 3.5 seconds.
  • On the map. In the drawing's own coordinates (UTM or any proj4 system) or by a click; objects counted, lengths measured and capacity worked out from the modules.
  • For everyone. 14 languages, each with its flag, Arabic and Persian right to left, counts and digits as each language writes them, keyboard and screen-reader use, light and dark themes, phones and tablets, and no tracking.
  • Measured in CI. Unit, reader and end-to-end tests on desktop and phone, with limits on reading time, memory and download size.
  • React 19
  • TypeScript
  • .NET 10 → WebAssembly
  • ACadSharp
  • Leaflet
  • proj4
  • Vite
  • Vitest
  • Playwright
v0.7.0 free, in any browser
plantline's plant layout: a solar plant on satellite imagery with an inverter described
plantline's diagram editor: a solar plant's single-line diagram with a transformer's properties plantline's diagram editor in the dark theme, its language list open: 14 languages, each with its flag
plantline on a phone, in Persian, right to left

Web app · Learning energy protocols

Gridlingo

How energy devices talk, explained visually, byte by byte.

A free, visual way to learn the protocols of the grid, from IEC 61850 GOOSE and IEC 60870-5-104 to DNP3, Modbus, OCPP, DLMS/COSEM, PROFINET and Zigbee Smart Energy. Each lesson plays a real exchange between real devices: watch the messages travel across the site, step by step, then open any message and read every byte. For engineers, students and anyone curious, with plain words for beginners.

  • 48 protocols, one way to learn. Substations, control centres, plants, EV charging, metering, IoT and security, each told as a short story between devices you can recognise.
  • Watch it happen. The messages travel across an isometric site, one after another; the same exchange is also shown as a sequence, a single-line diagram for substations and a timing chart.
  • Every byte explained. Each message taken apart in colour, field by field, with names and addresses broken down; the bytes are proven by tests, and where they are not certain the lesson says so in words.
  • Try it yourself. Turn a value into its bytes in every byte order, explore an IEC 61850 SCL file, set an EV charger's pilot signal, compare protocols side by side, and look up 470+ terms.
  • For everyone. 14 languages, Arabic and Persian right to left, technical or plain words, light and dark themes, phones and tablets, and no tracking: progress is kept only in the browser.
  • React 19
  • TypeScript
  • Vite
  • Tailwind CSS
  • shadcn/ui
  • Vitest
  • Playwright
v0.1.0 free, in any browser
Gridlingo's home page: 48 protocols in seven groups, beside a small energy site
A Gridlingo lesson on IEC 61850 GOOSE: a protection relay announces a trip to every subscriber across the substation The same GOOSE lesson in the dark theme
A Gridlingo lesson on IEC 60870-5-104 on a phone, in Persian, right to left

npm package · Node.js runtime

@araminix/platform

An actor-based application runtime and WebSocket platform for Node.js.

Write applications as TypeScript classes. The platform runs every opened app in its own worker thread, streams the UI tree and its updates to the browser over multiplexed WebSocket streams, and routes commands between apps and external agents such as devices or services.

  • One worker per app. Each app instance runs in its own worker thread with memory limits, timeouts and forced termination: one app cannot take the server down.
  • Server-driven UI on actors. Pages return actors instead of touching the UI; updates are applied under a per-instance lock, so actions, timers and requests never interleave.
  • Agents. External processes connect as agents, each served by its own worker, exchanging typed tasks and messages with the apps.
  • Hardened endpoint. Signed httpOnly sessions, a CSRF guard, origin checks, rate-limited sign-in, two-factor hooks, verified Google sign-in, safe uploads and presigned S3/MinIO links.
  • No exceptions in the API. Every fallible call returns a Result; error codes reach clients, error objects only reach the log.
  • Node.js 22+
  • TypeScript
  • Express 5
  • WebSocket
  • worker_threads
  • MinIO / S3
  • io-ts
  • node:test
v2.4.1
Browseruser A Browseruser B Deviceor service Endpointsessions · 2FA CSRF guardorigin checksrate limitsuploads Agent linkx-token Platformmain thread routes streams App · worker 1$open · $patch · $nextApp · worker 2$open · $patch · $nextApp · worker 3$open · $patch · $next Agent · workertasks and messages

npm package · Browser and Node.js

@araminix/lib

Universal, type-safe multiplexed WebSocket streaming.

The communication layer of the Araminix stack: any number of independent, typed, bidirectional streams over a single WebSocket, kept alive across network drops, with every failure reported as a Result instead of an exception. The same code runs in browsers and in Node.js.

  • Multiplexed streams. Each stream has a name, typed arguments, typed messages both ways, its own lifecycle and bounded queues.
  • Resilient by design. Reconnects with exponential backoff and jitter, resumes on the new socket and detects dead peers with per-stream heartbeats.
  • Validated protocol. Every frame is checked against an io-ts codec; malformed frames are dropped.
  • Isomorphic. Native WebSocket in browsers and Node.js 22+, no polyfills, ESM with types and declaration maps.
  • TypeScript
  • WebSocket
  • io-ts
  • fp-ts
  • ESM
  • node:test
v3.1.0
Clientbrowser or Node.js Server@araminix/platform one WebSocket chat ⇄ ask → notifications ← files → heartbeats · resumable reconnects · Result<T, E>
const socket = (await client.connect('chat', 'room-42')).unwrap();
const opened = await socket.outgoingStream<Topic, string, string>(
    'ask', { topic: 'weather' });
if (opened.isOk()) {
    const stream = opened.unwrap();
    await stream.write('Will it rain tomorrow?');
    // Result<string, StreamErr>, never a throw
    const answer = await stream.read(10);
}

Open source

Libraries and starters

One person, one account: the Araminix organisation belongs to amin-abbasi, and so does everything here. A library on npm and the micro-service starters, then studies from real work.

npm package · Terminal output

gach

Chainable colours and styles for terminal text.

A small TypeScript library for colouring console output: named colours, RGB and hex, bold, italic, underline and more, chained on one call. Types included, nothing else to install, and it turns its colours off when NO_COLOR is set. It colours the logs of @araminix/lib, both micro-service starters and the Node.js performance study.

  • One chain, any order. color and bgColor by name, rgb and hex, bold, italic, underline, strikethrough and inverse, each returning the same object, and reset to start again.
  • Presets. success, error, warning and rainbow for the usual messages, and customStyle to set several at once or add any ANSI code, such as one of the 256 colours.
  • Typed, no dependencies. Written in TypeScript with its declarations; colour names are checked by the compiler, and the whole package is under 30 KB.
  • Polite in any terminal. NO_COLOR turns colours off and FORCE_COLOR turns them on, as in Node.js; a wrong colour is reported, never thrown.
  • In use since 2021. 18 releases on npm, about 3,700 downloads in the last year, and tests that run before every release.
  • TypeScript
  • ANSI escape codes
  • Node.js
  • node:test
  • npm
v1.8.1
import gach from 'gach';

console.log(gach('✔ Deployed to production').success().text);
console.log(gach('⚠ Disk almost full').warning().text);
console.log(gach('✖ Payment service is down').error().text);
console.log(gach('Brand colour #FF7733').hex('#FF7733').text);
console.log(gach('Release 1.8 is out').rainbow().text);

Starters · TypeScript and JavaScript

Micro-service boilerplates

A layered Express service to start from, in TypeScript or JavaScript.

Two starters for REST micro-services on Express 5, built up over six years. Each request passes the same layers: security middlewares, routes, validation, controllers, services and repositories, with the database behind one interface. The TypeScript one is kept as a reference architecture; the JavaScript one is maintained.

  • Layered. Routes, validators, controllers, services and repositories, each in its own folder; validation with Zod (TypeScript) or Joi (JavaScript).
  • Your database. MongoDB with Mongoose, or MySQL and PostgreSQL with TypeORM, behind the same repository interface; Redis for caching.
  • Production basics. Helmet, CORS, rate limiting, JWT sign-in with roles, request logs, one error format and messages in English and Persian. No keys in the repository: one command makes a certificate for local HTTPS.
  • Documented and real-time. OpenAPI (Swagger) pages from the routes, and Socket.IO ready to switch on.
  • Tested and containerised. Jest and Supertest; the TypeScript one runs its integration tests against MongoDB and MySQL in Docker Compose, in CI on GitHub Actions.
  • Node.js
  • Express 5
  • TypeScript
  • JavaScript
  • MongoDB
  • TypeORM
  • Redis
  • Socket.IO
  • OpenAPI
  • Jest
  • Docker
42 stars · TypeScript4 stars · JavaScript
RequestHTTP · JSON Middlewareshelmet · CORS · rate limit · JWT and roles · i18n · request logs Routes/api/…ValidationZod or JoiControllersone per resourceServicesthe business rulesRepositoriesone interface OpenAPI pagesfrom the routes Socket.IOready to switch on Rediscache MongoDBMongoose SQLTypeORM Tested JestSupertestDockerComposeGitHubActions

Studies and a Go starter

Study

ArangoDB edge patterns for ERP

amin-abbasi/arango-edge-patterns

Graph patterns from real ERP systems: category trees, warehouse hierarchies and traversals on ArangoDB edge collections, tested against a real database, with the article that explains them.

  • ArangoDB
  • Graphs
  • ERP
  • Jest

Study

The Leaky Pipe: Node.js performance gotchas

amin-abbasi/node-performance-gotchas

Memory leaks, event-loop blocking and stream backpressure, each as a problem endpoint and a fixed one, with scripts that load them and show the difference.

  • Node.js
  • V8
  • Streams
TypeScript 3

Study

FlashScale: a flash-sale system design

amin-abbasi/system-design-flash-sale

Sharding, cache-aside and load balancing simulated in one process, with stress tests from ten thousand to a million orders.

  • Sharding
  • Caching
  • Load balancing
TypeScript 1

Starter

Go server boilerplate

amin-abbasi/go-boilerplate

A Go service with the Echo framework, MongoDB, Redis and JWT authentication, run with Docker and live reload.

  • Echo
  • MongoDB
  • JWT
  • Docker
Go 2

Every repository on GitHub

Capabilities

What we build

From the wire protocol to the screen an engineer works on.

Real-time systems

Multiplexed WebSocket protocols, actor runtimes and streaming pipelines that keep their promises under load and across network drops.

Resilient backends

Worker isolation, backpressure, timeouts and typed results instead of exceptions, in Node.js, Go and .NET.

Software for energy

Single-line diagrams, DWG/DXF processing and GIS placement for solar, wind, storage, hydro and grid projects, and the device protocols of the grid explained byte by byte.

Security by design

Hardened sessions and uploads, content security policies, audits and their fixes, shipped as part of the work, not after it.

The modern web platform

WebAssembly, canvas and SVG rendering at scale, right-to-left languages, and privacy by default.

Quality you can measure

Tests at every level, CI limits on time, memory and size, and documentation written as part of the product.

How we work

  • Zero crashes by designFailures are values, isolated and recovered from, never surprises.
  • Typed end to endFrom the wire format to the UI, the compiler checks the contract.
  • Measured, not guessedReal files and real numbers before and after every change.
  • Secure by defaultNothing leaves the user's device unless it has to.
  • Documented like a productEvery package ships a full guide and API reference.
  • Open by defaultMIT and Apache licences, changelogs and a history anyone can review.

The tools we know well

Languages

  • TypeScript
  • JavaScript
  • C# / .NET
  • Go
  • Python

Runtimes and frameworks

  • Node.js
  • Express
  • NestJS
  • React
  • ASP.NET Core
  • Echo, Gin and Fiber
  • Flask
  • WebAssembly

Real-time and messaging

  • WebSocket
  • Socket.IO
  • gRPC
  • RabbitMQ
  • WebRTC (OpenVidu)

Data

  • MongoDB
  • MySQL
  • PostgreSQL
  • Redis
  • ArangoDB
  • MinIO / S3

Delivery

  • Docker
  • GitHub Actions
  • pnpm
  • Vite
  • Vitest
  • Jest
  • Playwright
  • xUnit
  • node:test

Domains

  • Power plants and grids
  • CAD and GIS
  • ERP and MES
  • Trading and wallets
  • Healthcare (FHIR)
  • CRM and social networks
  • Video calls
Amin Abbasi

About

Amin Abbasi

Founder · Lead backend architect · Türkiye

Araminix is Amin Abbasi's own organisation, owned by the same GitHub account as every repository on this page: the runtimes, protocols and tools Amin wanted to build on, published, tested and documented.

Amin is a lead backend architect with more than ten years in Node.js, distributed systems and real-time pipelines, across manufacturing, energy, trading, healthcare and social platforms. A surveying engineer by training, at home with coordinates, maps and CAD, which plantline puts to work, and years in energy software, which Gridlingo shares.

years building backends
10+
engineers mentored
30+
companies
8
industries
5

Selected results

  • A server-driven UI framework over WebSockets that cut front-end releases by 80%: the model @araminix/platform is built on.
  • An ERP and MES monolith split into independently deployable services: features in a week instead of a month.
  • A trading engine with 30% faster order matching, and price feeds over RabbitMQ at twice the throughput.
  • ArangoDB queries tuned to 60 ms at more than 1,500 requests a second.
  • A CRM of more than 30 Node.js micro-services, and teams grown from 4 to 9 engineers and led at 12.

Writing

DEV Community · March 2026

Escaping “Recursive Hell”: Building ERP Hierarchies with ArangoDB Edges

Why adjacency lists break down in real ERP data, and how edge collections and graph traversals model categories, warehouses and bills of materials instead.

Building something real-time, or software for power plants?

Open an issue on any repository, or write to Amin through amin-abbasi.github.io or on X.