# Memahami Istilah Penting di Node.js – Node-API, Addon C/C++, FFI, ABI, POSIX, dan Evolusi Runtime JavaScript

Dalam dunia JavaScript backend, terutama ketika membicarakan performa, integrasi native, dan kompatibilitas lintas platform, ada beberapa istilah teknis yang *wajib* dipahami. Artikel ini membahas secara lengkap berbagai istilah tersebut, serta hubungannya dengan Node.js dan alternatif modern seperti Bun.

---

# 🧩 **1\. Node-API (N-API)**

### **Apa itu Node-API?**

Node-API (sering disebut N-API) adalah **abstraksi resmi** dalam Node.js untuk membangun *native addon* dengan bahasa C atau C++.  
Ini adalah API tingkat stabil yang memungkinkan kita:

* memanggil fungsi C/C++
    
* membuat modul `.node`
    
* mengakses memory native
    
* melakukan operasi berat (misal image processing, machine learning, crypto)
    

### **Kelebihan Node-API**

* **Stabil:** tidak rusak meski Node.js update major version
    
* **Lintas-OS:** binary bisa di-*build* untuk Linux, Mac, dan Windows
    
* **Didukung resmi:** cocok untuk library besar seperti `sharp`, `bcrypt`, `node-canvas`, `puppeteer` (Chromium bindings), dan `tensorflow.js-node`
    

### **Contoh library yang menggunakan Node-API**

* Sharp (image processing)
    
* Canvas (render)
    
* Bcrypt native
    
* TensorFlow.js Node binding
    
* SQLite native addons
    
* ZeroMQ
    
* libusb
    

Inilah alasan **Node.js sangat kuat di ekosistem native**.

---

# 🧩 **2\. Node Addon C/C++**

### **Apa itu addon?**

Addon adalah **file binary** dengan ekstensi:

* `.node` (khusus Node.js)
    
* menggunakan Node-API atau nan
    
* hasil compile dari C/C++ ke format binary OS
    

Addons menghubungkan JavaScript dengan performa native.

### Contoh:

```typescript
libtensorflow_linux.node
bcrypt_win32.node
canvas.node
```

Addon ini hanya bisa dijalankan oleh **Node.js**, bukan Bun, bukan Deno.

---

# 🧩 **3\. FFI (Foreign Function Interface)**

### **Pengertian**

FFI adalah cara memanggil **library** `.so`, `.dll`, `.dylib` langsung dari JavaScript *tanpa* membuat Node addon.

FFI menyediakan API seperti:

```js
ffi.open("libexample.so").symbols.myFunction();
```

### Kelebihan FFI

* Sangat fleksibel
    
* Tidak tergantung Node-API
    
* Tidak perlu compile ulang `.node`
    

### Kekurangan

* Tidak secepat Node-API
    
* Bergantung pada format OS (ELF, Mach-O, PE)
    

### Status

* Node.js → ada modul pihak ketiga (`ffi-napi`)
    
* Bun → punya FFI bawaan
    
* Deno → punya FFI bawaan
    

---

# 🧩 **4\. ABI (Application Binary Interface)**

ABI menentukan:

* bagaimana function dipanggil (calling convention)
    
* bagaimana register CPU dipakai
    
* struktur memory
    
* binary format (`.so`, `.dll`, `.dylib`)
    
* cara loader memuat library
    

### Perbedaan ABI antar OS

| OS | Format | ABI |
| --- | --- | --- |
| Linux | ELF | glibc/musl |
| MacOS | Mach-O | libc Apple |
| Windows | PE | Win32/MSVC |

**Addons Node.js untuk Linux tidak bisa dipakai di MacOS atau Windows** → karena ABI berbeda.

ABI = “bahasa native” CPU/OS.

---

# 🧩 **5\. POSIX / POSIX-Compliant**

POSIX = standar sistem operasi mirip UNIX (Portable Operating System Interface).

### OS yang POSIX-compliant:

* Linux
    
* macOS
    
* FreeBSD
    

### OS yang **TIDAK** POSIX:

* Windows
    

### Dampak Utama POSIX

Inilah sebab library seperti `sharp`, `canvas`, `libvips`, `cairo`, `freetype`, `png`, dll lebih mudah jalan:

* Linux → ✔
    
* macOS → ✔
    
* Windows → ❌ khusus (perlu build tool yang rumit)
    

POSIX membuat:

* filesystem mirip
    
* permission mirip
    
* libc mirip
    
* syscall mirip
    

Karena itu dev tool Linux/Mac jauh lebih kompatibel.

---

# 🧩 **6\. PUB (Portable POSIX-like UNIX Binary)**

PUB = binary yang kompatibel di sistem UNIX-like (Linux & macOS), karena hal seperti:

* struktur folder mirip
    
* standar libc mirip
    
* mode file mirip
    
* toolchain compatible (clang/gcc)
    

Tetapi PUB **tidak kompatibel** ke Windows karena format PE berbeda.

---

# 🧩 **7\. Hubungan Semua Istilah: Kenapa di Node Bisa, Tapi di Bun Tidak?**

### TensorFlow.js Node

* memakai Node-API
    
* memakai addon `.node`
    
* libtensorflow C++ sangat besar
    
* butuh loader `process.dlopen()` milik Node.js
    

### Node.js → bisa

Karena Node membuat ekosistem lengkap di atas:

* ABI stabil
    
* Node-API stabil
    
* modul `.node`
    
* node-gyp
    

### Bun → tidak bisa

Karena Bun:

* tidak 100% support Node-API
    
* tidak support binary `.node` (C++ addon)
    
* tidak punya loader native seperti Node.js
    

Bun cepat, tetapi bukan pengganti semua fitur Node.

---

# 🧩 **8\. Node.js Sekarang Mengikuti Perkembangan Bun**

Dulu Node.js lambat berinovasi. Tetapi mulai Node 18–20–22:

### Node sekarang punya:

* `--watch`
    
* `--env-file`
    
* `--experimental-loader`
    
* `node:test` (testing bawaan Node)
    
* ESM lebih stabil
    
* flag modern `--run`, `--import`
    
* runtime API lebih rapi
    

### Untuk testing cepat → bisa pakai:

* Vitest
    
* Node:test
    
* TAP
    

Node sekarang sudah modern, meski tidak secepat Bun di cold start.

---

# 🧩 **9\. Node.js ESM vs Bun ESM**

### Node ESM:

* paling kompatibel
    
* paling luas dukungannya
    
* dipakai oleh library besar
    
* lambat tapi stabil
    

### Bun ESM:

* sangat cepat
    
* banyak fitur built-in
    
* tetapi tidak mendukung native addon `.node`
    

Sederhananya:

| Feature | Node | Bun |
| --- | --- | --- |
| Speed | ❗ lambat | ⚡ sangat cepat |
| Native C++ addon | ✔ penuh | ❌ tidak |
| FFI | modul pihak ketiga | ✔ built-in |
| Testing built-in | ✔ | ✔ |
| Dependency cleanup | sedang berkembang | sangat bagus |
| Kompatibilitas NPM | paling lengkap | hampir lengkap |
| ML/AI Native | ✔ (tfjs-node, onnxruntime-node) | ❌ |

---

# 🧩 **10\. Kesimpulan Besar**

### ✔ Node.js:

* paling kompatibel
    
* mendukung Node-API, addon `.node`, native module
    
* kuat untuk AI, gambar, multimedia, ML
    
* lebih matang berkat ESM modern, `--watch`, `--env`, dan `node:test`
    

### ✔ Bun:

* paling cepat
    
* lengkap untuk web dev (HTTP, HTMLRewriter, test, env)
    
* tapi **tidak cocok untuk native-heavy workloads** seperti:
    
    * TensorFlow
        
    * FFmpeg full bindings
        
    * GPU processing
        
    * TensorRT, CUDA, OpenCV
        

### POSIX, ABI, Node-API, FFI =

fondasi untuk mengerti mengapa library tertentu bisa jalan di Node.js tapi tidak di Bun.