Erlk1m Blog

Tutorial Rust WebAssembly (WASM): Menjalankan Kode Rust di Browser untuk Pemula

Fri, 06 Nov 2026 19:55:00 GMT

Pendahuluan

WebAssembly (WASM) telah merevolusi kemampuan browser modern. Jika sebelumnya JavaScript adalah satu-satunya bahasa pemrograman yang dapat berjalan langsung di sisi client (browser), kini WebAssembly memungkinkan kita menjalankan kode biner berkecepatan tinggi dengan performa mendekati native (near-native speed).

Dari sekian banyak bahasa pemrograman yang mendukung kompilasi ke WebAssembly, Rust adalah pilihan yang paling populer dan matang. Mengapa?

Tanpa Garbage Collector (GC): Rust menggunakan sistem ownership untuk manajemen memori, sehingga runtime WASM sangat ramping tanpa overhead jeda GC.
Ukuran Binary Sangat Kecil: Hanya modul yang benar-benar digunakan yang disertakan dalam output WASM.
Ekosistem Terbaik: Tools seperti wasm-pack dan library wasm-bindgen membuat komunikasi dua arah antara Rust dan JavaScript terasa sangat mulus.
Aman dan Andal: Menghindari memory leak dan kesalahan akses memori sejak fase kompilasi.

WebAssembly dirancang bukan untuk menggantikan JavaScript, melainkan untuk bekerja berdampingan dengan JavaScript. Gunakan JavaScript untuk manipulasi DOM dan routing, serta gunakan WebAssembly untuk komputasi berat, manipulasi media, enkripsi, dan grafis!

Prasyarat dan Instalasi Toolchain

Sebelum mulai, pastikan komputer Anda sudah terpasang perangkat lunak berikut:

Rust dan Cargo

Jika belum memiliki Rust, pasang melalui toolchain resmi:

# Untuk Linux / macOS / WSL
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Verifikasi instalasi
rustc --version
cargo --version

WASM Target

Tambahkan target kompilasi WebAssembly ke toolchain Rust Anda:

rustup target add wasm32-unknown-unknown

wasm-pack

wasm-pack adalah tool serbaguna untuk membangun, mengemas, dan mengoptimalkan package WebAssembly Rust agar siap dikonsumsi oleh JavaScript / bundler web.

cargo install wasm-pack

Langkah 1: Inisialisasi Project Rust

Buat sebuah library Rust baru menggunakan Cargo:

cargo new --lib rust-wasm-demo
cd rust-wasm-demo

Struktur folder awal yang dihasilkan:

rust-wasm-demo/
├── Cargo.toml
└── src/
    └── lib.rs

Langkah 2: Konfigurasi Cargo.toml

Buka file Cargo.toml dan sesuaikan kodenya. Kita perlu memberitahu Cargo agar mengompilasi project ini sebagai cdylib (C dynamic library) dan menyertakan dependensi wasm-bindgen.

[package]
name = "rust-wasm-demo"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
wasm-bindgen = "0.2"

crate-type = ["cdylib"] wajib disertakan agar compiler Rust menghasilkan file biner .wasm yang dapat diekspor, bukan pustaka Rust standar (rlib).

Langkah 3: Menulis Kode Rust

Buka file src/lib.rs dan ganti isinya dengan kode berikut:

use wasm_bindgen::prelude::*;

// Mengimpor fungsi `alert` dari Web API (JavaScript window)
#[wasm_bindgen]
extern "C" {
    fn alert(s: &str);
}

// Fungsi 1: Menampilkan popup browser dari Rust
#[wasm_bindgen]
pub fn sapa(nama: &str) {
    alert(&format!("Halo {}! Salam dari kode Rust di WebAssembly ", nama));
}

// Fungsi 2: Komputasi berat (Fibonacci Rekursif) untuk uji performa
#[wasm_bindgen]
pub fn hitung_fibonacci(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => hitung_fibonacci(n - 1) + hitung_fibonacci(n - 2),
    }
}

// Fungsi 3: Operasi manipulasi string sederhana
#[wasm_bindgen]
pub fn balik_kata(teks: &str) -> String {
    teks.chars().rev().collect()
}

Makro #[wasm_bindgen] bertugas otomatis menangani marshalling tipe data kompleks seperti String dan &str agar bisa dimengerti oleh runtime JavaScript.

Langkah 4: Kompilasi ke WebAssembly dengan wasm-pack

Jalankan perintah berikut di direktori project:

wasm-pack build --target web

Perintah di atas akan membuat folder baru bernama pkg/ yang berisi:

rust_wasm_demo_bg.wasm: File biner WebAssembly hasil kompilasi.
rust_wasm_demo.js: Wrapper JavaScript ES Module untuk memuat dan mengikat fungsi-fungsi WASM.
rust_wasm_demo.d.ts: TypeScript definition untuk auto-complete editor.
package.json: Metadata package jika ingin dipublikasikan ke npm.

Langkah 5: Membuat Antarmuka Web (HTML & JavaScript)

Sekarang buat file index.html di root project untuk menguji modul WASM yang sudah dibuat:

<!DOCTYPE html>
<html lang="id">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>Uji Coba Rust WebAssembly</title>
  <style>
    body {
      font-family: system-ui, -apple-system, sans-serif;
      max-width: 600px;
      margin: 40px auto;
      padding: 0 20px;
      line-height: 1.6;
    }
    input, button {
      padding: 8px 14px;
      font-size: 14px;
      margin: 5px 0;
    }
    .card {
      border: 1px solid #e2e8f0;
      border-radius: 8px;
      padding: 16px;
      margin-bottom: 20px;
      background: #f8fafc;
    }
  </style>
</head>
<body>
  <h1> Demo Rust WebAssembly</h1>
  <p>Semua logika di bawah dieksekusi langsung oleh WebAssembly di browser Anda.</p>

  <!-- Bagian 1: Sapaan -->
  <div class="card">
    <h3>1. Panggil Web API (Alert)</h3>
    <input type="text" id="inputNama" placeholder="Masukkan nama Anda..." value="Developer" />
    <br />
    <button id="btnSapa">Kirim Sapaan</button>
  </div>

  <!-- Bagian 2: Balik Kata -->
  <div class="card">
    <h3>2. Manipulasi String (Reverse)</h3>
    <input type="text" id="inputText" placeholder="Ketik kalimat..." value="Halo Dunia" />
    <br />
    <button id="btnBalik">Balik Teks</button>
    <p>Hasil: <strong id="hasilBalik">-</strong></p>
  </div>

  <!-- Bagian 3: Komputasi Fibonacci -->
  <div class="card">
    <h3>3. Uji Kecepatan Komputasi (Fibonacci)</h3>
    <input type="number" id="inputFibo" value="35" min="1" max="45" />
    <br />
    <button id="btnFibo">Hitung dengan Rust</button>
    <p>Hasil: <strong id="hasilFibo">-</strong></p>
    <p><small id="durasiFibo"></small></p>
  </div>

  <script type="module">
    // Import loader dan fungsi langsung dari folder pkg
    import init, { sapa, balik_kata, hitung_fibonacci } from './pkg/rust_wasm_demo.js';

    async function run() {
      // Inisialisasi modul WASM
      await init();
      console.log('Modul WebAssembly berhasil dimuat!');

      // Event Sapaan
      document.getElementById('btnSapa').addEventListener('click', () => {
        const nama = document.getElementById('inputNama').value;
        sapa(nama);
      });

      // Event Balik Kata
      document.getElementById('btnBalik').addEventListener('click', () => {
        const teks = document.getElementById('inputText').value;
        const hasil = balik_kata(teks);
        document.getElementById('hasilBalik').textContent = hasil;
      });

      // Event Uji Fibonacci
      document.getElementById('btnFibo').addEventListener('click', () => {
        const n = parseInt(document.getElementById('inputFibo').value, 10);
        
        const mulai = performance.now();
        const hasil = hitung_fibonacci(n);
        const selesai = performance.now();
        
        document.getElementById('hasilFibo').textContent = hasil;
        document.getElementById('durasiFibo').textContent = 
          `Waktu eksekusi Rust WASM: ${(selesai - mulai).toFixed(2)} ms`;
      });
    }

    run();
  </script>
</body>
</html>

Langkah 6: Menjalankan Local Web Server

Karena WebAssembly memuat file .wasm secara asinkron menggunakan protokol fetch, browser tidak mengizinkan membukanya langsung via file://. Anda perlu menjalankannya lewat web server lokal:

# Menggunakan Python
python3 -m http.server 8080

# Atau menggunakan npx serve
npx serve .

Buka browser Anda di http://localhost:8080 dan Anda akan melihat antarmuka interaktif yang ditenagai oleh Rust!

Kapan Sebaiknya Menggunakan WebAssembly?

Meskipun WebAssembly sangat cepat, bukan berarti semua kode JavaScript harus diganti dengan WASM. WebAssembly sangat tepat digunakan untuk skenario:

Pemrosesan Gambar & Audio/Video: Manipulasi kanvas, filter foto, atau encoder/decoder video (misalnya ffmpeg WASM).
Game & Grafis 3D: Menggunakan WebGL / WebGPU dengan game engine seperti Bevy.
Kriptografi & Enkripsi: Hashing data besar, enkripsi end-to-end, dan pemrosesan kunci privat.
Parsing Format Kompleks: Parser dokumen (PDF, Markdown, Spreadsheet) berukuran raksasa.
Porting Library Native C/C++/Rust: Menjalankan library desktop yang sudah ada langsung di web tanpa menulis ulang dari nol.

Tips Optimasi Ukuran File WASM

Untuk deployment ke lingkungan produksi, ukuran file biner .wasm bisa diperkecil drastis dengan menambahkan profil release di Cargo.toml:

[profile.release]
opt-level = "z"     # Optimalkan ukuran binary sekecil mungkin
lto = true          # Link Time Optimization antar modul
codegen-units = 1   # Maksimalkan reduksi ukuran
panic = "abort"     # Hapus pesan unwind panic untuk memangkas bytes

Kompilasi mode produksi:

wasm-pack build --target web --release

Dengan optimasi di atas, ukuran file .wasm hasil kompilasi bisa menyusut hingga lebih dari 60%, membuat proses download di browser client menjadi sangat instan!

Kesimpulan

Menggabungkan Rust dan WebAssembly membuka jalan baru untuk membangun aplikasi web berperforma tinggi. Dengan ekosistem wasm-bindgen dan wasm-pack, proses integrasi ke aplikasi web modern menjadi sangat intuitif tanpa mengorbankan keamanan memori khas Rust.

Selamat mencoba, dan mulailah membawa kekuatan komputasi native ke dalam browser Anda!

Docker: Container untuk Modern Development

Tue, 16 Jun 2026 02:30:00 GMT

Docker merevolusi cara developer membangun dan menjalankan aplikasi dengan teknologi container yang ringan, portabel, dan konsisten di berbagai lingkungan.

ChatGPT: Revolusi Kecerdasan Buatan yang Mengubah Cara Kita Bekerja dan Belajar

Tue, 16 Jun 2026 02:00:00 GMT

test 12345

Tue, 16 Jun 2026 00:25:00 GMT

123

MiMo V2.5 Pro — Model AI Terkuat Xiaomi yang Menyaingi Frontier Model Dunia

Mon, 15 Jun 2026 23:24:00 GMT

MiMo V2.5 Pro — Model AI Terkuat Xiaomi yang Menyaingi Frontier Model Dunia

Pendahuluan

Xiaomi bukan sekadar perusahaan smartphone. Dengan dirilisnya MiMo V2.5 Pro pada 22 April 2026, Xiaomi membuktikan bahwa mereka mampu membangun model bahasa yang bersaing di level frontier global. Model ini menjadi open weights model pertama yang menyamai performa model proprietary terdepan dalam benchmark agentic.

Dengan lebih dari 1 triliun parameter total namun hanya mengaktifkan 42 miliar parameter per inference pass, MiMo V2.5 Pro menawarkan kombinasi langka: kecerdasan tingkat frontier dengan biaya inferensi yang sangat efisien.

Spesifikasi Utama

Spesifikasi	Detail
Total Parameter	1.02T (Mixture-of-Experts)
Parameter Aktif	42B per forward pass
Context Window	1M token
Arsitektur	Hybrid Attention (SWA + GA, rasio 6 )
Multi-Token Prediction	3 layer MTP (triple output speed)
Pelatihan	27T token, FP8 mixed precision
Lisensi	MIT (open weights)
Harga API	1.00input/1.00 input / 1.00input/3.00 output per 1M token

Arsitektur: Hybrid Attention + Mixture-of-Experts

Hybrid Attention

MiMo V2.5 Pro menggunakan arsitektur hybrid attention yang menggabungkan dua jenis mekanisme perhatian:

Sliding Window Attention (SWA) — 60 layer, untuk efisiensi pada konteks lokal
Global Attention (GA) — 10 layer, untuk memahami hubungan jarak jauh

Dengan rasio 6

(SWA

), penyimpanan KV-cache berkurang hampir 7x tanpa mengorbankan performa konteks panjang.

Komponen Arsitektur	MiMo V2.5 Pro	MiMo V2.5
Total Parameter	1.02T	310B
Parameter Aktif	42B	15B
Hidden Size	6144	4096
Jumlah Layer	70 (1 dense + 69 MoE)	48 (1 dense + 47 MoE)
Full Attention Layer	10	9
SWA Layer	60	39
Attention Heads	128	64
KV Heads	8 (GQA)	8 (GA) / 4 (SWA)
Routed Experts	384	256
Expert per Token	8	8

Multi-Token Prediction (MTP)

Dengan 3 lightweight MTP modules menggunakan dense FFN, kecepatan output meningkat hingga 3x lipat.

Benchmark Performa

Artificial Analysis Intelligence Index

Model	Intelligence Index	Biaya Run	Output Token
MiMo V2.5 Pro	54	$462	~92M
Kimi K2.6	54	$948	~170M
GLM-5.1	—	$544	~110M

Kemampuan Agentic (GDPval-AA)

Peringkat	Model	Skor GDPval-AA
1	MiMo V2.5 Pro	1578
2	DeepSeek V4 Pro	1554
3	GLM-5.1	1535
4	MiniMax-M2.7	1514
5	Kimi K2.6	1484

Benchmark Base Model

Kategori	Benchmark	MiMo V2.5 Pro	MiMo V2.5
General	BBH (3-shot)	88.4	87.2
General	MMLU (5-shot)	89.4	86.3
Math	GSM8K (8-shot)	99.6	83.3
Math	MATH (4-shot)	86.2	67.7
Code	HumanEval+ (1-shot)	75.6	71.3
Code	LiveCodeBench v6	39.6	35.5
Chinese	C-Eval (5-shot)	91.5	88.6

Kemampuan Agentic: Bukan Sekadar Chatbot

Studi Kasus: Compiler SysY dalam Rust

Waktu pengerjaan mahasiswa: Beberapa minggu
Waktu MiMo V2.5 Pro: 4.3 jam, 672 tool calls
Hasil: Skor sempurna 233/233 pada hidden test suite

Studi Kasus: Video Editor Desktop

Total kode: 8.192 baris
Tool calls: 1.868
Waktu: 11.5 jam kerja autonom

Perbandingan dengan Model Lain

Aspek	MiMo V2.5 Pro	Claude Opus 4.6	DeepSeek V4 Pro	GPT-5.2
Total Parameter	1.02T	Proprietary	1.6T	Proprietary
Active Parameter	42B	Proprietary	49B	Proprietary
Context Window	1M token	200K	128K	128K
GDPval-AA	1578	—	1554	—
ClawEval	61.5	66.3	—	50.0
PinchBench	81.0	81.5	—	77.0
Harga/1M token	1/1 / 1/3	15/15 / 15/75	0.27/0.27 / 0.27/1.10	2/2 / 2/8
Lisensi	MIT (open)	Proprietary	MIT (open)	Proprietary

Long Context: Performa di 1 Juta Token

Panjang Konteks	MiMo V2.5 Pro (BFS)	MiMo V2.5 Pro (Parents)	MiMo V2 Pro (BFS)	MiMo V2 Pro (Parents)
32K	Tinggi	Tinggi	Tinggi	Tinggi
128K	Tinggi	Tinggi	Mulai turun	Mulai turun
512K	0.56	0.92	0.00	0.00
1M	0.37	0.62	0.00	0.00

Model Keluarga MiMo V2.5

Model	Tanggal Rilis	Keunggulan Utama
MiMo V2.5 Pro	22 April 2026	Flagship, agentic terkuat, 1T params
MiMo V2.5	23 April 2026	Multimodal native, 310B params
MiMo V2.5 TTS	23 April 2026	Text-to-speech, voice cloning
MiMo V2.5 ASR	2 Juni 2026	Speech recognition, dialek Tiongkok

Cara Menggunakan

Via API

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.mimo.xiaomi.com/v1"
)

response = client.chat.completions.create(
    model="mimo-v2.5-pro",
    messages=[
        {"role": "user", "content": "Jelaskan arsitektur Mixture-of-Experts"}
    ],
    max_tokens=2048
)

print(response.choices[0].message.content)

Self-Hosting Requirements

Kebutuhan	Minimum	Direkomendasikan
GPU	4x A100 80GB	8x H100 80GB
RAM	128GB	256GB
Storage	2TB NVMe	4TB NVMe
Framework	vLLM / SGLang	vLLM dengan MTP support

Ekosistem dan Integrasi

Framework	Tipe	Status
OpenClaw	General-purpose agent	Partner resmi
OpenCode	Coding agent	Partner resmi
KiloCode	Coding agent	Partner resmi
Claude Code	Coding harness	Didukung resmi
Blackbox	AI coding	Partner resmi
Cline	VS Code agent	Partner resmi

Kesimpulan

MiMo V2.5 Pro menandai era baru di mana perusahaan seperti Xiaomi mampu membangun AI yang bersaing di level tertinggi. Dengan performa agentic #1, biaya 25x lebih murah dari Claude Opus 4.6, context window 1M token, dan lisensi MIT — frontier AI kini lebih terjangkau dari sebelumnya.

Bagi developer Indonesia, dengan $3 per juta output token, Anda sudah bisa memanfaatkan kecerdasan sekelas model terbaik dunia.

Artikel ini ditulis berdasarkan data benchmark dari Artificial Analysis dan dokumentasi resmi Xiaomi MiMo, April-Juni 2026.

test table

Mon, 15 Jun 2026 22:15:00 GMT

Kolom 1	Kolom 2	Kolom 3
Data 1	Data 2	Data 3
Data 4	Data 5	Data 6

Setup Home Server Lengkap dengan Armbian + Docker Compose

Mon, 15 Jun 2026 22:01:00 GMT

Panduan membangun home server all-in-one dengan Armbian menggunakan Docker Compose. Install Pi-hole, Jellyfin, dan File Browser dalam satu board ARM.

Armbian Server di TV Box Amlogic — Ubah Android TV Box Jadi Linux Server Murah

Mon, 15 Jun 2026 21:26:00 GMT

Armbian Server di TV Box Amlogic — Ubah Android TV Box Jadi Linux Server Murah

Pendahuluan

TV Box berchipset Amlogic (S905X, S905W, S905X2, S912, S922X) yang beredar di pasaran dengan harga Rp 150 ribu - 400 ribu ternyata bisa diubah menjadi Linux server yang sangat capable dengan Armbian.

Dibanding membeli Raspberry Pi yang harganya naik drastis, TV Box Amlogic menawarkan:

RAM 2-4GB dengan harga sangat terjangkau
Storage internal eMMC yang lebih cepat dari SD Card
Port Ethernet 100Mbps atau Gigabit
USB 2.0/3.0 untuk hard disk eksternal
HDMI untuk troubleshooting langsung

Artikel ini akan membahas cara mengubah TV Box Amlogic Anda menjadi server Linux produktif dengan Armbian.

TV Box Amlogic yang Kompatibel

Chipset yang Didukung Armbian

S905X — MXQ Pro 4K, T95X, X96 — RAM 1-2GB, cocok untuk server ringan
S905W — X96 Mini, T95 Mini — Versi low-power S905X, hemat listrik
S905X2 — X96 Max, HK1 Box — Lebih cepat, USB 3.0, RAM 2-4GB
S912 — T95Z Plus, TX9 Pro — Octa-core, cocok untuk media server
S922X — Ugoos AM6, Odroid N2+ — Performa tinggi, harga lebih mahal
S905X3 — X96 Air, HK1 X3 — Support mainline kernel modern

Cek Chipset TV Box Anda

Sebelum mulai, pastikan chipset TV Box Anda:

Lihat stiker di bawah unit — biasanya tertulis S905X, S912, dll
Cek dengan AIDA64 — install dari Play Store, lihat bagian CPU
Cek di forum Armbian — cari model TV Box Anda di forum.armbian.com

> Peringatan: Tidak semua TV Box Amlogic bisa boot Armbian. Beberapa memiliki bootloader terkunci atau WiFi/BT chip yang tidak ada driver Linux. Ethernet biasanya selalu berfungsi.

Alat dan Bahan

TV Box Amlogic — Pastikan chipset didukung
MicroSD Card — 16GB atau lebih (Class 10/UHS-I)
Card Reader — USB Card Reader
Kabel Ethernet — Untuk koneksi network
Mouse & Keyboard — Untuk konfigurasi awal (opsional)
HDMI Monitor — Untuk melihat proses boot pertama
Toothpick / Jarum — Untuk masuk ke recovery/boot mode

Langkah 1: Download Armbian untuk Amlogic

Pilih Image yang Tepat

Kunjungi halaman Armbian untuk Amlogic:
github.com/ophub/amlogic-s9xxx-armbian
Pilih image sesuai chipset Anda:
- Armbian_xxx_Aml_s905x_bullseye_xxx.img.gz → untuk S905X
- Armbian_xxx_Aml_s912_bullseye_xxx.img.gz → untuk S912
- Armbian_xxx_Aml_s905x2_bullseye_xxx.img.gz → untuk S905X2
Pilih versi Server (CLI) jika tujuannya pure server.
Pilih versi Desktop jika butuh GUI sesekali.

> Tips: Versi Bullseye (Debian 11) atau Bookworm (Debian 12) lebih stabil untuk server. Versi Jammy (Ubuntu 22.04) jika butuh package lebih baru.

Langkah 2: Flash Image ke MicroSD

Menggunakan BalenaEtcher

Buka BalenaEtcher
Pilih file .img atau .img.gz Armbian
Pilih MicroSD Card
Klik Flash

Menggunakan `dd` (Linux)

# Cek device SD card
lsblk

# Flash (GANTI sdX dengan device Anda!)
sudo dd if=Armbian_xxx.img of=/dev/sdX bs=4M status=progress conv=fsyn

Catatan: Jika TV Box tetap boot ke Android, kemungkinan bootloader tidak mendukung SD boot. Solusi: flash Armbian ke internal eMMC (dibahas di bagian lanjutan).

Langkah 4: Boot Pertama & Konfigurasi

Proses Boot

TV Box akan boot dari MicroSD
Tampilan awal akan resize filesystem (tunggu 1-2 menit)
Login prompt muncul

Login Default

Username	Password
`root`	`1234`

First Boot Wizard

Setelah login, wizard akan meminta:

Ubah password root
Buat user baru (wajib, root login via SSH akan disabled)
Pilih timezone → Asia/Jakarta
Pilih locale → en_US.UTF-8
Pilih shell → bash

Langkah 5: Install Armbian ke Internal eMMC (Opsional tapi Direkomendasikan)

Boot dari MicroSD lebih lambat dan tidak stabil untuk long-term. Sebaiknya install Armbian ke internal eMMC TV Box.

Cek eMMC Terdeteksi

bash

lsblk
# Cari device seperti /dev/mmcblk1 atau /dev/mmcblk2

Install ke eMMC dengan `armbian-install`

bash

# Jalankan script install
sudo armbian-install

# Atau jika tidak tersedia:
sudo nand-sata-install

Pilihan yang muncul:

Boot from eMMC → install sistem ke eMMC
Boot from SD / system on eMMC → boot dari SD tapi rootfs di eMMC
Boot from eMMC / system on SATA/NVMe → untuk USB/SATA

Pilih opsi 1 untuk install penuh ke eMMC.

Peringatan: Proses ini akan menghapus Android di TV Box Anda. Pastikan sudah yakin!

Setelah selesai:

bash

sudo poweroff

Cabut MicroSD, lalu nyalakan TV Box. Sekarang Armbian akan boot langsung dari eMMC yang jauh lebih cepat.

Langkah 6: Optimasi untuk Server

1. Disable GUI (Jika Install Versi Desktop)

Jika Anda install versi desktop tapi ingin pure server:

bash

# Disable display manager
sudo systemctl disable lightdm gdm3 sddm

# Set multi-user target (CLI only)
sudo systemctl set-default multi-user.target

# Reboot
sudo reboot

2. Optimasi CPU Governor

bash

sudo nano /etc/default/cpufrequtils

Isi:

bash

ENABLE=true
GOVERNOR=ondemand
MIN_SPEED=100000
MAX_SPEED=1900000

Restart:

bash

sudo systemctl restart cpufrequtils

3. Disable Bluetooth & WiFi (Jika Tidak Digunakan)

Hemat RAM dan CPU:

bash

sudo systemctl disable bluetooth
sudo systemctl disable bluetooth.service
sudo systemctl disable NetworkManager-wait-online.service

# Blacklist driver WiFi (jika WiFi tidak stabil di Linux)
echo "blacklist dhd" | sudo tee -a /etc/modprobe.d/blacklist.conf
echo "blacklist cfg80211" | sudo tee -a /etc/modprobe.d/blacklist.conf

4. Setup Static IP

bash

sudo nano /etc/network/interfaces

Isi:

bash

auto eth0
iface eth0 inet static
    address 192.168.1.100
    netmask 255.255.255.0
    gateway 192.168.1.1
    dns-nameservers 1.1.1.1 8.8.8.8

Restart network:

bash

sudo systemctl restart networking

5. Thermal Management

TV Box Amlogic cenderung panas. Pastikan cooling cukup:

bash

# Cek suhu CPU
cat /sys/class/thermal/thermal_zone0/temp
# Output: 45000 = 45°C

# Install fan control (jika ada fan)
sudo apt install lm-sensors -y

Langkah 7: Install Docker & Deploy Aplikasi Server

Setelah Armbian berjalan optimal, install Docker untuk menjalankan berbagai service:

Install Docker

bash

curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
newgrp docker

Install Docker Compose

bash

sudo apt install docker-compose-plugin -y

Project 1: File Browser (NAS Ringan)

yaml

# docker-compose.yml
version: "3"
services:
  filebrowser:
    image: filebrowser/filebrowser:s6
    container_name: filebrowser
    ports:
      - "8080:80"
    volumes:
      - /:/srv
      - ./filebrowser.db:/database.db
    restart: unless-stopped

Project 2: Pi-hole

yaml

version: "3"
services:
  pihole:
    image: pihole/pihole:latest
    container_name: pihole
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "8081:80/tcp"
    environment:
      TZ: 'Asia/Jakarta'
      WEBPASSWORD: 'admin123'
    volumes:
      - './etc-pihole:/etc/pihole'
      - './etc-dnsmasq.d:/etc/dnsmasq.d'
    restart: unless-stopped

Project 3: Uptime Kuma (Monitoring)

yaml

version: "3"
services:
  uptime-kuma:
    image: louislam/uptime-kuma:latest
    container_name: uptime-kuma
    ports:
      - "3001:3001"
    volumes:
      - ./uptime-kuma-data:/app/data
    restart: unless-stopped

Troubleshooting Khusus Amlogic

TV Box Boot Loop ke Android

Solusi: Bootloader Android masih aktif. Gunakan Amlogic USB Burning Tool untuk flash custom bootloader, atau gunakan Multitool dari balena150.

Ethernet Tidak Terdeteksi

Solusi: Beberapa TV Box menggunakan chip Ethernet yang tidak umum. Cek dengan:

bash

dmesg | grep -i eth
lspci
lsusb

Jika tidak terdeteksi, cari driver spesifik di forum Armbian atau gunakan USB Ethernet Adapter.

HDMI Tidak Keluar Output

Solusi: Beberapa TV Box membutuhkan DTB (Device Tree Blob) yang tepat. Ganti file .dtb di /boot/dtb/amlogic/ dengan yang sesuai model TV Box Anda.

Panas Berlebihan & Thermal Throttling

Solusi:

Tambahkan heatsink pada chip Amlogic
Pasang fan kecil 5V di dalam casing
Turunkan MAX_SPEED di cpufrequtils
Pastikan casing TV Box tidak tertutup rapat

WiFi Tidak Berfungsi

Solusi: WiFi di TV Box Amlogic sangat sering tidak ada driver Linux. Solusi terbaik adalah menggunakan kabel Ethernet atau USB WiFi Adapter yang support Linux (Realtek RTL8812AU, MT7601U).

Perbandingan TV Box Amlogic vs Raspberry Pi

Spesifikasi	TV Box Amlogic S905X2	Raspberry Pi 4 2GB
Harga	Rp 250-350 ribu	Rp 600-800 ribu
CPU	Quad-core Cortex-A53	Quad-core Cortex-A72
RAM	2-4GB DDR3/4	2-8GB LPDDR4
Storage	eMMC 8-16GB + MicroSD	MicroSD only
Ethernet	100M / Gigabit	Gigabit
USB	USB 2.0 / 3.0	USB 2.0 + 3.0
GPIO	Tidak ada	40-pin GPIO
Komunitas	Aktif (China/Internasional)	Sangat besar

Kesimpulan: Jika Anda butuh server headless tanpa GPIO, TV Box Amlogic adalah pilihan jauh lebih hemat biaya. Raspberry Pi unggul jika butuh GPIO, kamera, atau HAT.

Kesimpulan

TV Box Amlogic yang terbengkalai bisa dihidupkan kembali sebagai Linux server yang powerful dengan Armbian. Dengan biaya di bawah Rp 400 ribu, Anda mendapatkan:

Server Linux 24/7 dengan konsumsi daya 5-10 watt
Storage internal eMMC yang lebih cepat dari SD Card
Kemampuan menjalankan Docker, NAS, Pi-hole, Home Assistant
Upgrade path ke eMMC untuk performa lebih baik

Meskipun ada keterbatasan seperti tidak adanya GPIO dan WiFi yang sering tidak support, untuk use case server jaringan dan home automation, TV Box Amlogic + Armbian adalah kombinasi yang sangat worth it.

Siap mengubah TV Box tua Anda menjadi server produktif?

Cara Install Docker di Armbian untuk Pemula — Lengkap dengan Contoh Project

Mon, 15 Jun 2026 21:02:00 GMT

Cara Install Docker di Armbian untuk Pemula — Lengkap dengan Contoh Project

Kenapa Docker di Armbian?

Docker adalah platform containerization yang memungkinkan Anda menjalankan aplikasi dalam lingkungan terisolasi tanpa perlu menginstall dependency satu per satu di sistem utama.

Keuntungan menggunakan Docker di board ARM dengan Armbian:

Isolasi aplikasi — tiap app punya environment sendiri
Mudah backup — cukup backup volume container
Portability — docker-compose.yml bisa dipindah ke board lain
Rollback mudah — hapus container dan buat ulang jika error
Hemat resource — lebih ringan dari VM

Persiapan Sebelum Install

Pastikan sistem Armbian Anda sudah:

✅ Update ke versi terbaru
✅ Memiliki koneksi internet stabil
✅ Minimal 1GB RAM (2GB lebih baik untuk multiple container)

Cek versi Armbian Anda:

cat /etc/os-releas

Pastikan Anda menggunakan Armbian berbasis Debian atau Ubuntu (Bookworm, Jammy, atau Bullseye).

Langkah 1: Update Sistem

bash

sudo apt update && sudo apt upgrade -y
sudo apt install ca-certificates curl gnupg lsb-release -y

Langkah 2: Install Docker Official

Tambahkan Docker GPG Key

bash

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

Tambahkan Docker Repository

bash

echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Catatan: Jika Anda menggunakan Ubuntu-based Armbian, ganti debian menjadi ubuntu pada URL di atas.

Install Docker Engine

bash

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Verifikasi Installasi

bash

sudo docker --version
sudo docker compose version

Output yang diharapkan:

plain

Docker version 27.x.x, build xxxxx
Docker Compose version v2.x.x

Langkah 3: Jalankan Docker Tanpa Sudo (Opsional)

Secara default, Docker hanya bisa dijalankan dengan sudo. Agar user biasa bisa menjalankan Docker:

bash

# Tambahkan user ke grup docker
sudo usermod -aG docker $USER

# Apply perubahan (logout dan login ulang, atau reboot)
newgrp docker

Test:

bash

docker run hello-world

Jika berhasil, Anda akan melihat pesan Hello from Docker!.

Langkah 4: Install Docker Compose Standalone (Opsional)

Meskipun Docker sudah menyertakan docker compose (plugin), beberapa orang lebih nyaman dengan binary docker-compose:

bash

# Download versi terbaru untuk ARM64
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-linux-aarch64" -o /usr/local/bin/docker-compose

# Beri permission execute
sudo chmod +x /usr/local/bin/docker-compose

# Verifikasi
docker-compose --version

Langkah 5: Project Pertama — Nginx Web Server

Buat folder project dan jalankan container Nginx:

bash

mkdir ~/docker-projects && cd ~/docker-projects
mkdir nginx-test && cd nginx-test

Buat file docker-compose.yml:

yaml

version: "3.8"

services:
  nginx:
    image: nginx:alpine
    container_name: nginx-web
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
    restart: unless-stopped

Buat folder html dan file index.html:

bash

mkdir html
echo "<h1>Hello from Armbian + Docker!</h1>" > html/index.html

Jalankan container:

bash

docker compose up -d

Buka browser dan akses: http://IP-BOARD:8080

Langkah 6: Project Kedua — Pi-hole dengan Docker

bash

cd ~/docker-projects
mkdir pihole && cd pihole

File docker-compose.yml:

yaml

version: "3.8"

services:
  pihole:
    image: pihole/pihole:latest
    container_name: pihole
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "8081:80/tcp"
    environment:
      TZ: 'Asia/Jakarta'
      WEBPASSWORD: 'passwordadmin'
    volumes:
      - './etc-pihole:/etc/pihole'
      - './etc-dnsmasq.d:/etc/dnsmasq.d'
    restart: unless-stopped

Jalankan:

bash

docker compose up -d

Akses dashboard: http://IP-BOARD:8081/admin

Langkah 7: Project Ketiga — Home Assistant

bash

cd ~/docker-projects
mkdir homeassistant && cd homeassistant

File docker-compose.yml:

yaml

version: "3.8"

services:
  homeassistant:
    image: ghcr.io/home-assistant/home-assistant:stable
    container_name: homeassistant
    privileged: true
    restart: unless-stopped
    environment:
      - TZ=Asia/Jakarta
    volumes:
      - ./config:/config
    network_mode: host

Jalankan:

bash

docker compose up -d

Akses UI: http://IP-BOARD:8123

Perintah Docker yang Sering Digunakan

Perintah	Fungsi
`docker ps`	Lihat container yang berjalan
`docker ps -a`	Lihat semua container (aktif & mati)
`docker logs CONTAINER`	Lihat log container
`docker stop CONTAINER`	Hentikan container
`docker start CONTAINER`	Jalankan container
`docker rm CONTAINER`	Hapus container
`docker images`	Lihat image yang tersedia
`docker compose down`	Hentikan dan hapus container + network
`docker compose pull`	Download image terbaru
`docker compose up -d`	Jalankan container di background
`docker exec -it CONTAINER bash`	Masuk ke shell container

Troubleshooting

Docker Service Tidak Berjalan

bash

sudo systemctl status docker
sudo systemctl start docker
sudo systemctl enable docker

Permission Denied

Pastikan user sudah ditambahkan ke grup docker dan sudah logout-login ulang.

Container Exit Terus

Cek log container untuk error:

bash

docker logs --tail 50 CONTAINER_NAME

Port Sudah Digunakan

Cek port yang aktif:

bash

sudo ss -tlnp | grep :PORT

Ubah port mapping di docker-compose.yml jika bentrok.

Tips Optimasi Docker di Board ARM

1. Gunakan Image Alpine atau Slim

Image berbasis Alpine lebih kecil dan hemat RAM:

nginx:alpine vs nginx:latest
python:3.11-alpine vs python:3.11

2. Limit Resource Container

yaml

services:
  app:
    image: some-image
    deploy:
      resources:
        limits:
          cpus: '1.0'
          memory: 512M

3. Enable Docker Log Rotation

Edit /etc/docker/daemon.json:

JSON

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}

Restart Docker:

bash

sudo systemctl restart docker

Kesimpulan

Dengan Docker di Armbian, Anda bisa:

Menjalankan banyak aplikasi dalam satu board tanpa konflik dependency
Mudah backup dan restore project
Eksperimen aman — salah konfigurasi? Hapus container dan ulang
Deploy cepat — cukup docker compose up -d

Dari web server sederhana hingga smart home server, Docker membuat manajemen aplikasi di board ARM menjadi jauh lebih mudah dan terstruktur.

Selamat mencoba!

5 Project Keren yang Bisa Dibuat dengan Armbian di Board ARM

Mon, 15 Jun 2026 20:57:00 GMT

5 Project Keren yang Bisa Dibuat dengan Armbian di Board ARM

Pendahuluan

Setelah berhasil menginstall Armbian di board ARM seperti Orange Pi, NanoPi, atau Rock Pi, banyak pengguna bertanya-tanya: “Lalu, mau diapain?”

Board ARM yang menjalankan Armbian sebenarnya adalah mini komputer Linux yang sangat powerful. Dengan konsumsi daya rendah (biasanya 5-15 watt), board ini bisa berjalan 24/7 tanpa khawatir tagihan listrik membengkak. Berikut adalah 5 project praktis yang bisa Anda bangun dengan Armbian.

Project 1: Personal NAS (Network Attached Storage)

Jadikan board ARM Anda sebagai cloud storage pribadi di rumah.

Mengapa NAS?

Akses file dari mana saja dalam jaringan rumah
Backup otomatis dari laptop dan smartphone
Biaya rendah dibanding beli NAS komersial (Synology, QNAP)

Tools yang Digunakan

Software	Fungsi
Samba	Sharing folder ke Windows/Mac/Linux
OpenMediaVault (OMV)	Web-based NAS management
Syncthing	Sinkronisasi file antar device
Nextcloud	Cloud storage dengan web interface

Langkah Singkat

# Install Samba
sudo apt install samba samba-common-bin -y

# Setup shared folder
sudo mkdir -p /mnt/nas-storage
sudo chmod 777 /mnt/nas-storage

# Edit konfigurasi Samba
sudo nano /etc/samba/smb.conf

# Tambahkan di bagian bawah:
[nas-share]
path = /mnt/nas-storage
writeable = yes
create mask = 0777
directory mask = 0777
public = yes

# Restart Samba
sudo systemctl restart smb

Tips: Tambahkan hard disk USB 3.0 eksternal untuk kapasitas besar. Format dengan ext4 agar lebih cepat dan stabil.\

Project 2: Pi-hole — Ad Blocker untuk Seluruh Jaringan

Blokir iklan dan tracker di semua device rumah Anda dengan sekali setup.

Cara Kerja Pi-hole

Pi-hole bertindak sebagai DNS server di jaringan Anda. Setiap kali device meminta akses ke domain iklan (misalnya googleadservices.com), Pi-hole akan memblokirnya sebelum iklan terdownload.

Keuntungan

Blokir iklan di semua device (HP, laptop, TV smart, bahkan console game)
Blokir tracker dan malware domain
Lihat statistik website apa saja yang diakses di rumah
Hemat bandwidth dan baterai HP

Install Pi-hole di Armbian

bash

# One-liner install Pi-hole
curl -sSL https://install.pi-hole.net | bash

Setelah install, arahkan DNS router Anda ke IP board ARM. Atau set DNS manual di setiap device:

Primary DNS: IP board ARM Anda
Secondary DNS: 1.1.1.1 (Cloudflare) sebagai backup

Akses Dashboard: Buka http://IP-BOARD/admin di browser.

Project 3: Home Assistant — Smart Home Server

Kendalikan lampu, AC, kipas, dan sensor IoT dari satu dashboard.

Apa itu Home Assistant?

Home Assistant adalah platform open-source home automation yang mendukung ribuan device dari berbagai merek: Xiaomi, Philips Hue, Tuya, Sonoff, ESP8266, dan banyak lagi.

Kenapa Jalankan di Armbian?

Privasi — data smart home Anda tidak dikirim ke cloud pihak ketiga
Lokal — berjalan 100% di jaringan rumah, internet mati pun tetap jalan
Gratis — tidak perlu berlangganan layanan cloud

Install Home Assistant Container

bash

# Install Docker terlebih dahulu
sudo apt install docker.io docker-compose -y
sudo systemctl enable docker

# Jalankan Home Assistant
sudo docker run -d \
  --name homeassistant \
  --privileged \
  --restart=unless-stopped \
  -e TZ=Asia/Jakarta \
  -v /home/$(whoami)/homeassistant:/config \
  --network=host \
  ghcr.io/home-assistant/home-assistant:stable

Akses UI: http://IP-BOARD:8123

Dengan Home Assistant, Anda bisa membuat automasi seperti: “Jika sensor gerak terdeteksi di malam hari, nyalakan lampu hallway selama 5 menit.”

Project 4: Media Server dengan Jellyfin

Streaming film, musik, dan foto koleksi pribadi ke TV, HP, atau laptop.

Jellyfin vs Plex

Table

Fitur	Jellyfin	Plex
Harga	Gratis & open-source	Freemium (fitur premium berbayar)
Privasi	100% lokal	Memerlukan akun cloud
Transcoding	Tergantung hardware board	Sama
Plugin	Aktif dikembangkan komunitas	Lebih mature

Install Jellyfin

bash

# Tambahkan repo Jellyfin
curl -fsSL https://repo.jellyfin.org/debian/jellyfin_team.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/jellyfin.gpg

# Tambahkan source list
echo "deb [signed-by=/usr/share/keyrings/jellyfin.gpg] https://repo.jellyfin.org/debian $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/jellyfin.list

# Install
sudo apt update
sudo apt install jellyfin -y

# Enable service
sudo systemctl enable --now jellyfin

Akses UI: http://IP-BOARD:8096

Tips Transcoding: Board ARM dengan GPU Mali (seperti Orange Pi 5) mendukung hardware transcoding via FFmpeg. Ini memungkinkan streaming 4K ke device lemah tanpa patah-patah.

Project 5: Web Server + Reverse Proxy (Nginx + Docker)

Host website pribadi, blog, atau aplikasi web di board ARM Anda sendiri.

Stack yang Digunakan

Table

Komponen	Fungsi
Nginx Proxy Manager	Reverse proxy + SSL otomatis (Let’s Encrypt)
Docker + Portainer	Manajemen container via GUI
WordPress / Ghost	CMS untuk blog
Uptime Kuma	Monitoring uptime website

Setup dengan Docker Compose

bash

# Buat folder project
mkdir ~/docker-server && cd ~/docker-server

# Buat file docker-compose.yml
nano docker-compose.yml

Isi docker-compose.yml:

yaml

version: "3"

services:
  nginx-proxy-manager:
    image: jc21/nginx-proxy-manager:latest
    restart: unless-stopped
    ports:
      - "80:80"
      - "81:81"
      - "443:443"
    volumes:
      - ./npm-data:/data
      - ./letsencrypt:/etc/letsencrypt

  portainer:
    image: portainer/portainer-ce:latest
    restart: unless-stopped
    ports:
      - "9000:9000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./portainer-data:/data

Jalankan:

bash

sudo docker-compose up -d

Akses Nginx Proxy Manager: http://IP-BOARD:81
Akses Portainer: http://IP-BOARD:9000

Dengan Nginx Proxy Manager, Anda bisa mendapatkan SSL gratis dari Let’s Encrypt untuk domain Anda (misal: blog.rumahku.duckdns.org) dengan sekali klik.

Perbandingan Daya dan Biaya

Table

Project	CPU Usage	RAM Usage	Cocok untuk Board
NAS (Samba)	Rendah	100-200 MB	Orange Pi Zero 2
Pi-hole	Sangat rendah	50-100 MB	NanoPi NEO
Home Assistant	Sedang	300-500 MB	Orange Pi 3 LTS
Jellyfin	Tinggi (saat transcode)	500 MB - 1 GB	Orange Pi 5 / RK3588
Web Server	Rendah-Sedang	200-400 MB	Banana Pi M5

Catatan: Board dengan RAM 1GB masih cukup untuk project 1-3. Untuk Jellyfin dan web server, disarankan minimal 2GB RAM.

Kesimpulan

Board ARM + Armbian adalah kombinasi yang sangat versatile dan hemat biaya. Dengan investasi board seharga Rp 200 ribu - 1 jutaan, Anda bisa membangun:

Cloud storage pribadi
Ad blocker jaringan
Smart home server
Media streaming server
Web server pribadi

Semua project ini berjalan 24/7 dengan konsumsi daya setara 1-2 lampu LED. Jauh lebih hemat dibanding menyewa VPS cloud yang biayanya puluhan dollar per bulan.

Kimi AI - Asisten Cerdas dari Tiongkok yang Mengubah Cara Kita Bekerja

Mon, 15 Jun 2026 20:26:00 GMT

Kimi AI: Asisten Cerdas dari Tiongkok yang Mengubah Cara Kita Bekerja

Pengenalan

Di era kecerdasan buatan yang semakin kompetitif, Kimi AI hadir sebagai salah satu asisten AI paling menonjol dari Tiongkok. Dikembangkan oleh Moonshot AI (月之暗面), Kimi AI menawarkan kemampuan pemrosesan teks yang luar biasa dengan fokus pada penanganan dokumen panjang dan pemahaman konteks yang mendalam.

Apa itu Kimi AI?

Kimi AI adalah model bahasa besar (Large Language Model/LLM) yang dirancang untuk menjadi asisten pribadi yang mampu:

Memproses dokumen hingga ratusan ribu kata dalam satu sesi
Memahami konteks panjang dengan sangat baik
Menjawab pertanyaan kompleks dalam berbagai bidang
Membantu penulisan, analisis, dan riset dengan akurat

Keunggulan Utama Kimi AI

1. Context Window yang Sangat Besar

Salah satu keunggulan terbesar Kimi AI adalah kemampuannya menangani context window yang sangat panjang. Dibandingkan banyak model AI lainnya, Kimi dapat memproses dokumen panjang seperti laporan, kontrak, atau buku tanpa kehilangan konteks.

2. Dukungan Bahasa yang Kuat

Kimi AI memiliki pemahaman mendalam terhadap bahasa Mandarin dan juga berbagai bahasa lainnya, termasuk bahasa Indonesia, Inggris, dan banyak bahasa Asia lainnya.

3. Integrasi dengan Berbagai Format

Kimi dapat membaca dan menganalisis berbagai format dokumen seperti:

PDF
Word (DOC/DOCX)
File teks
Gambar (untuk versi tertentu)

4. Kecepatan dan Akurasi

Dengan arsitektur modern, Kimi AI mampu memberikan respons yang cepat dan akurat, bahkan untuk pertanyaan teknis atau analisis data.

Cara Menggunakan Kimi AI

Pengguna dapat mengakses Kimi AI melalui:

Website resmi: kimi.moonshot.cn
Aplikasi mobile: tersedia di iOS dan Android
API: untuk pengembang yang ingin mengintegrasikan Kimi ke dalam aplikasi mereka

Perbandingan dengan Asisten AI Lainnya

Fitur	Kimi AI	ChatGPT	Claude
Context Window	Sangat besar	Besar	Sangat besar
Bahasa Mandarin	⭐⭐⭐	⭐⭐	⭐⭐
Analisis Dokumen	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐
Kecepatan	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐

Kesimpulan

Kimi AI merupakan bukti bahwa inovasi dalam bidang kecerdasan buatan tidak hanya berpusat di Silicon Valley. Dengan kemampuan memproses dokumen panjang, pemahaman bahasa yang kuat, dan performa yang handal, Kimi AI layak menjadi pilihan bagi siapa saja yang membutuhkan asisten digital cerdas.

Baik Anda seorang penulis, peneliti, pengusaha, atau pelajar, Kimi AI dapat membantu meningkatkan produktivitas dan efisiensi kerja Anda.

Rust Web Development: Membuat REST API dengan Actix-web

Mon, 15 Jun 2026 19:50:00 GMT

Rust bukan hanya untuk sistem programming dan CLI tools — ia juga sangat powerful untuk web development. Dengan framework seperti Actix-web, kamu bisa membangun REST API yang cepat, aman, dan scalable. Artikel ini membawa kamu membangun API lengkap dari nol.

1. Apa Itu Actix-web?

Actix-web adalah framework web untuk Rust yang berbasis actor system. Ia menawarkan:

• Performa tinggi — salah satu framework web tercepat di benchmark
• Type-safe routing — routing diperiksa pada waktu kompilasi
• Middleware yang fleksibel dan composable
• Async/await native
• Auto-reload untuk development

2. Setup Project

Buat project baru dan tambahkan dependency:

cargo new rust-api
cd rust-api

[package]
name = "rust-api"
version = "0.1.0"
edition = "2021"

[dependencies]
actix-web = "4"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

3. Hello World Server

Server Actix-web paling sederhana:

use actix_web::{get, App, HttpServer, Responder};

#[get("/")]
async fn hello() -> impl Responder {
    "Hello, Rust API!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new().service(hello)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Jalankan dengan:

cargo run

Test dengan curl:

curl http://localhost:8080/

4. Routing dengan Parameter

Actix-web mendukung path parameter dan query parameter:

use actix_web::{get, web, App, HttpServer, Responder};

#[get("/user/{id}")]
async fn get_user(path: web::Path) -> impl Responder {
    format!("User ID: {}", path.into_inner())
}

#[get("/search")]
async fn search(info: web::Query) -> impl Responder {
    format!("Searching for: {}", info.q)
}

#[derive(serde::Deserialize)]
struct SearchInfo {
    q: String,
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(get_user)
            .service(search)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Test:

curl http://localhost:8080/user/42
curl "http://localhost:8080/search?q=rust"

5. JSON Request dan Response

Actix-web otomatis meng-handle serialisasi dan deserialisasi JSON:

use actix_web::{post, web, App, HttpServer, HttpResponse, Responder};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
    email: String,
}

#[derive(Serialize)]
struct ApiResponse {
    success: bool,
    data: T,
}

#[post("/users")]
async fn create_user(user: web::Json) -> impl Responder {
    let response = ApiResponse {
        success: true,
        data: user.into_inner(),
    };
    HttpResponse::Ok().json(response)
}

#[get("/users/{id}")]
async fn get_user_by_id(path: web::Path) -> impl Responder {
    let user = User {
        id: path.into_inner(),
        name: String::from("Alice"),
        email: String::from("alice@example.com"),
    };
    HttpResponse::Ok().json(ApiResponse { success: true, data: user })
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(create_user)
            .service(get_user_by_id)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Test JSON API:

curl -X POST http://localhost:8080/users   -H "Content-Type: application/json"   -d '{"id": 1, "name": "Alice", "email": "alice@example.com"}'

curl http://localhost:8080/users/1

6. State dan Data Sharing

Gunakan web::Data untuk berbagi state antar handler:

use actix_web::{web, App, HttpServer, HttpResponse, Responder};
use std::sync::Mutex;

struct AppState {
    counter: Mutex,
}

async fn counter(data: web::Data) -> impl Responder {
    let mut counter = data.counter.lock().unwrap();
    *counter += 1;
    HttpResponse::Ok().body(format!("Count: {}", *counter))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let app_state = web::Data::new(AppState {
        counter: Mutex::new(0),
    });

    HttpServer::new(move || {
        App::new()
            .app_data(app_state.clone())
            .route("/counter", web::get().to(counter))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

7. Middleware

Actix-web menyediakan middleware bawaan dan memungkinkan custom middleware:

use actix_web::{middleware, web, App, HttpServer, HttpResponse};

async fn hello() -> HttpResponse {
    HttpResponse::Ok().body("Hello!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .wrap(middleware::Logger::default())
            .wrap(middleware::Compress::default())
            .wrap(middleware::NormalizePath::default())
            .route("/hello", web::get().to(hello))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Tambahkan di Cargo.toml:

[dependencies]
actix-web = "4"
env_logger = "0.11"

Inisialisasi logger di main.rs:

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
    // ... server code
}

8. Error Handling

Buat custom error response yang konsisten:

use actix_web::{http::StatusCode, web, HttpResponse, ResponseError};
use serde::Serialize;
use std::fmt;

#[derive(Serialize)]
struct ErrorResponse {
    success: bool,
    error: String,
}

#[derive(Debug)]
enum ApiError {
    NotFound,
    BadRequest(String),
    InternalError,
}

impl fmt::Display for ApiError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ApiError::NotFound => write!(f, "Resource not found"),
            ApiError::BadRequest(msg) => write!(f, "Bad request: {}", msg),
            ApiError::InternalError => write!(f, "Internal server error"),
        }
    }
}

impl ResponseError for ApiError {
    fn status_code(&self) -> StatusCode {
        match self {
            ApiError::NotFound => StatusCode::NOT_FOUND,
            ApiError::BadRequest(_) => StatusCode::BAD_REQUEST,
            ApiError::InternalError => StatusCode::INTERNAL_SERVER_ERROR,
        }
    }

    fn error_response(&self) -> HttpResponse {
        HttpResponse::build(self.status_code()).json(ErrorResponse {
            success: false,
            error: self.to_string(),
        })
    }
}

async fn get_item(path: web::Path) -> Result {
    let id = path.into_inner();
    if id == 0 {
        return Err(ApiError::BadRequest(String::from("ID must be > 0")));
    }
    if id > 100 {
        return Err(ApiError::NotFound);
    }
    Ok(HttpResponse::Ok().json(serde_json::json!({
        "success": true,
        "data": { "id": id, "name": "Item" }
    })))
}

9. CRUD API Lengkap

In-memory CRUD API dengan Actix-web:

use actix_web::{delete, get, post, put, web, App, HttpResponse, HttpServer};
use serde::{Deserialize, Serialize};
use std::sync::Mutex;

#[derive(Serialize, Deserialize, Clone)]
struct Todo {
    id: u32,
    title: String,
    completed: bool,
}

struct AppState {
    todos: Mutex>,
    next_id: Mutex,
}

#[get("/todos")]
async fn list_todos(data: web::Data) -> HttpResponse {
    let todos = data.todos.lock().unwrap();
    HttpResponse::Ok().json(&*todos)
}

#[post("/todos")]
async fn create_todo(
    data: web::Data,
    todo: web::Json,
) -> HttpResponse {
    let mut todos = data.todos.lock().unwrap();
    let mut next_id = data.next_id.lock().unwrap();
    
    let new_todo = Todo {
        id: *next_id,
        title: todo.title.clone(),
        completed: false,
    };
    *next_id += 1;
    todos.push(new_todo.clone());
    
    HttpResponse::Created().json(new_todo)
}

#[derive(Deserialize)]
struct CreateTodo {
    title: String,
}

#[get("/todos/{id}")]
async fn get_todo(data: web::Data, path: web::Path) -> HttpResponse {
    let todos = data.todos.lock().unwrap();
    match todos.iter().find(|t| t.id == path.into_inner()) {
        Some(todo) => HttpResponse::Ok().json(todo),
        None => HttpResponse::NotFound().body("Todo not found"),
    }
}

#[put("/todos/{id}")]
async fn update_todo(
    data: web::Data,
    path: web::Path,
    update: web::Json,
) -> HttpResponse {
    let mut todos = data.todos.lock().unwrap();
    match todos.iter_mut().find(|t| t.id == path.into_inner()) {
        Some(todo) => {
            todo.title = update.title.clone().unwrap_or(todo.title.clone());
            todo.completed = update.completed.unwrap_or(todo.completed);
            HttpResponse::Ok().json(todo)
        }
        None => HttpResponse::NotFound().body("Todo not found"),
    }
}

#[derive(Deserialize)]
struct UpdateTodo {
    title: Option,
    completed: Option,
}

#[delete("/todos/{id}")]
async fn delete_todo(data: web::Data, path: web::Path) -> HttpResponse {
    let mut todos = data.todos.lock().unwrap();
    let id = path.into_inner();
    let initial_len = todos.len();
    todos.retain(|t| t.id != id);
    
    if todos.len() < initial_len {
        HttpResponse::NoContent().finish()
    } else {
        HttpResponse::NotFound().body("Todo not found")
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let state = web::Data::new(AppState {
        todos: Mutex::new(vec![]),
        next_id: Mutex::new(1),
    });

    HttpServer::new(move || {
        App::new()
            .app_data(state.clone())
            .service(list_todos)
            .service(create_todo)
            .service(get_todo)
            .service(update_todo)
            .service(delete_todo)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Test CRUD:

curl -X POST http://localhost:8080/todos   -H "Content-Type: application/json"   -d '{"title": "Belajar Rust"}'

curl http://localhost:8080/todos

curl -X PUT http://localhost:8080/todos/1   -H "Content-Type: application/json"   -d '{"completed": true}'

curl -X DELETE http://localhost:8080/todos/1

10. Extractors dan Validasi

Actix-web mendukung banyak extractor untuk data yang berbeda:

use actix_web::{web, HttpRequest, HttpResponse};
use serde::Deserialize;

#[derive(Deserialize)]
struct Pagination {
    page: Option,
    per_page: Option,
}

async fn list_items(
    req: HttpRequest,
    query: web::Query,
    body: Option>,
) -> HttpResponse {
    let page = query.page.unwrap_or(1);
    let per_page = query.per_page.unwrap_or(10);
    
    let user_agent = req.headers().get("user-agent")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("unknown");
    
    HttpResponse::Ok().json(serde_json::json!({
        "page": page,
        "per_page": per_page,
        "user_agent": user_agent,
        "body_present": body.is_some()
    }))
}

Kesimpulan

Actix-web membuka dunia web development dengan Rust yang cepat dan aman. Dari artikel ini kamu telah belajar:

• Setup project Actix-web
• Routing dan parameter
• JSON request/response otomatis
• State sharing dengan web::Data
• Middleware untuk logging dan kompresi
• Custom error handling
• CRUD API lengkap
• Extractors untuk header, query, dan body

Selanjutnya, eksplorasi topik seperti: integrasi database dengan sqlx atau diesel, authentication dengan JWT, WebSocket, dan deployment ke container.

Rust untuk web bukan lagi masa depan — ia sudah siap untuk production.

Rust Async: Pemrograman Asinkron dengan async/await

Mon, 15 Jun 2026 19:45:00 GMT

Rust mendukung pemrograman asinkron melalui async/await, sebuah fitur yang memungkinkan kamu menulis kode non-blocking yang terlihat seperti kode sinkron biasa. Artikel ini membawa kamu dari konsep dasar futures hingga praktik concurrent tasks dengan Tokio.

1. Apa Itu Async di Rust?

Di Rust, fungsi async tidak langsung berjalan — ia mengembalikan sebuah Future. Future adalah nilai yang merepresentasikan komputasi yang belum selesai. Future baru dieksekusi ketika di-await atau dijalankan oleh runtime.

async fn hello() {
    println!("Hello dari async!");
}

fn main() {
    let future = hello();  // Future dibuat, tapi belum berjalan
    // Kode di sini belum mencetak apa pun
    
    // Untuk menjalankan, butuh runtime atau block_on
}

2. Menjalankan Future dengan block_on

Cara termudah menjalankan future adalah menggunakan futures::executor::block_on:

use futures::executor::block_on;

async fn hello() {
    println!("Hello, async world!");
}

fn main() {
    let future = hello();
    block_on(future);  // blokir sampai future selesai
}

Tambahkan dependency di Cargo.toml:

[dependencies]
futures = "0.3"

3. async/await dalam Praktik

await digunakan di dalam fungsi async lain untuk menunggu future selesai tanpa memblokir thread:

use std::time::Duration;
use async_std::task;

async fn tarea_satu() {
    task::sleep(Duration::from_secs(1)).await;
    println!("Tarea satu selesai");
}

async fn tarea_dua() {
    task::sleep(Duration::from_secs(2)).await;
    println!("Tarea dua selesai");
}

async fn run_both() {
    tarea_satu().await;
    tarea_dua().await;
}

fn main() {
    task::block_on(run_both());
}

Perhatikan: kode di atas berjalan secara berurutan, bukan paralel. Total waktu = 1 + 2 = 3 detik.

4. Menjalankan Task Secara Concurrent

Untuk menjalankan task secara bersamaan, gunakan join! atau futures::future::join:

use futures::join;
use std::time::Duration;
use async_std::task;

async fn fetch_user(id: u32) -> String {
    task::sleep(Duration::from_secs(1)).await;
    format!("User {}", id)
}

async fn fetch_order(id: u32) -> String {
    task::sleep(Duration::from_secs(1)).await;
    format!("Order {}", id)
}

async fn get_data() {
    let user_future = fetch_user(1);
    let order_future = fetch_order(101);
    
    let (user, order) = join!(user_future, order_future);
    println!("{} dan {} diambil bersamaan", user, order);
    // Total waktu ~1 detik, bukan 2 detik!
}

fn main() {
    async_std::task::block_on(get_data());
}

5. Tokio: Runtime Produksi untuk Rust

Tokio adalah runtime async paling populer di Rust. Ia menyediakan thread pool, timer, I/O, dan channel.

[dependencies]
tokio = { version = "1", features = ["full"] }

use tokio::time::{sleep, Duration};

async fn task_a() {
    sleep(Duration::from_secs(1)).await;
    println!("Task A selesai");
}

async fn task_b() {
    sleep(Duration::from_secs(1)).await;
    println!("Task B selesai");
}

#[tokio::main]
async fn main() {
    let start = std::time::Instant::now();
    
    tokio::join!(task_a(), task_b());
    
    println!("Waktu total: {:?}", start.elapsed());
    // ~1 detik, bukan 2 detik!
}

6. Spawning Task

tokio::spawn membuat task baru yang berjalan secara independen:

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let handle1 = tokio::spawn(async {
        sleep(Duration::from_secs(1)).await;
        println!("Spawn 1 selesai");
        42
    });
    
    let handle2 = tokio::spawn(async {
        sleep(Duration::from_secs(2)).await;
        println!("Spawn 2 selesai");
        "hello"
    });
    
    let result1 = handle1.await.unwrap();
    let result2 = handle2.await.unwrap();
    
    println!("Hasil: {} dan {}", result1, result2);
}

7. Channels untuk Komunikasi antar Task

use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    let (tx, mut rx) = mpsc::channel(100); // buffer 100
    
    let tx2 = tx.clone();
    
    tokio::spawn(async move {
        for i in 0..5 {
            tx.send(format!("Pesan dari A: {}", i)).await.unwrap();
        }
    });
    
    tokio::spawn(async move {
        for i in 5..10 {
            tx2.send(format!("Pesan dari B: {}", i)).await.unwrap();
        }
    });
    
    drop(tx); // tutup sender agar receiver tahu kapan selesai
    
    while let Some(msg) = rx.recv().await {
        println!("Diterima: {}", msg);
    }
    
    println!("Channel selesai");
}

8. Select: Menunggu Banyak Future

tokio::select! menunggu beberapa future dan menangani yang selesai pertama:

use tokio::time::{sleep, Duration};
use tokio::sync::oneshot;

#[tokio::main]
async fn main() {
    let (tx, rx) = oneshot::channel();
    
    tokio::spawn(async move {
        sleep(Duration::from_secs(2)).await;
        tx.send("Data dari task").unwrap();
    });
    
    tokio::select! {
        result = rx => {
            match result {
                Ok(msg) => println!("Diterima: {}", msg),
                Err(_) => println!("Sender dropped"),
            }
        }
        _ = sleep(Duration::from_secs(3)) => {
            println!("Timeout!");
        }
    }
}

9. Concurrent Stream Processing

use tokio::time::{sleep, Duration};

async fn download_file(id: u32) -> String {
    sleep(Duration::from_millis(500)).await;
    format!("File-{}.pdf", id)
}

#[tokio::main]
async fn main() {
    let ids = vec![1, 2, 3, 4, 5];
    
    // Sequential (lambat)
    for id in &ids {
        let file = download_file(*id).await;
        println!("Downloaded: {}", file);
    }
    
    println!("--- Sekarang concurrent ---");
    
    // Concurrent dengan FuturesUnordered (cepat)
    let mut tasks = tokio::task::JoinSet::new();
    for id in ids {
        tasks.spawn(download_file(id));
    }
    
    while let Some(res) = tasks.join_next().await {
        println!("Downloaded: {}", res.unwrap());
    }
}

10. Async Trait

Trait dengan method async memerlukan crate tambahan seperti async-trait:

[dependencies]
async-trait = "0.1"

use async_trait::async_trait;

#[async_trait]
trait Fetcher {
    async fn fetch(&self, url: &str) -> String;
}

struct HttpFetcher;

#[async_trait]
impl Fetcher for HttpFetcher {
    async fn fetch(&self, url: &str) -> String {
        format!("Fetched from {}", url)
    }
}

#[tokio::main]
async fn main() {
    let fetcher = HttpFetcher;
    let result = fetcher.fetch("https://rust-lang.org").await;
    println!("{}", result);
}

Kesimpulan

Async programming di Rust menawarkan performa tinggi dengan overhead minimal. Dengan async/await, kamu bisa menulis kode non-blocking yang bersih dan mudah dibaca. Tokio menyediakan ekosistem lengkap: runtime, I/O, timer, channel, dan utility untuk concurrent programming.

Hal yang perlu diingat:

• async fn mengembalikan Future, bukan langsung berjalan
• .await menunggu future di dalam konteks async
• tokio::join! untuk menjalankan task concurrent
• tokio::spawn untuk task yang berjalan independen
• tokio::select! untuk menangani event yang selesai pertama
• Channel untuk komunikasi antar task

Mulailah dengan contoh sederhana, lalu tingkatkan ke aplikasi yang lebih kompleks. Async Rust sangat powerful untuk web server, proxy, game server, dan sistem real-time. Selamat eksplorasi!

Tutorial Rust: Membuat CLI Tool dari Nol

Mon, 15 Jun 2026 19:35:00 GMT

Dalam tutorial ini, kamu akan membuat sebuah CLI tool sederhana dengan Rust: aplikasi command-line yang membaca file teks dan menghitung statistik seperti jumlah baris, kata, dan karakter. Kita mulai dari instalasi Rust hingga aplikasi yang bisa dijalankan langsung.

Prasyarat

Pastikan kamu sudah menginstal Rust:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustc --version
cargo --version

Langkah 1: Inisialisasi Project

Buat project baru dengan Cargo:

cargo new wordcount

cd wordcount

cargo run

Struktur folder yang dihasilkan:

wordcount/
├── Cargo.toml
├── src/
│   └── main.rs
└── target/
    └── debug/

Langkah 2: Membaca File

Edit src/main.rs untuk membaca file dari command-line:

use std::env;
use std::fs;

fn main() {
    let args: Vec = env::args().collect();

    if args.len() < 2 {
        eprintln!("Penggunaan: wordcount <file>");
        std::process::exit(1);
    }

    let filename = &args[1];
    let contents = fs::read_to_string(filename)
        .expect("Tidak bisa membaca file");

    println!("Isi file:
{}", contents);
}

Jalankan dengan:

echo "Hello Rust" > test.txt
cargo run -- test.txt

Langkah 3: Menghitung Statistik

Tambahkan fungsi untuk menghitung jumlah baris, kata, dan karakter:

fn count_stats(text: &str) -> (usize, usize, usize) {
    let lines = text.lines().count();
    let words = text.split_whitespace().count();
    let chars = text.chars().count();
    (lines, words, chars)
}

Ganti main untuk menggunakan fungsi tersebut:

use std::env;
use std::fs;

fn count_stats(text: &str) -> (usize, usize, usize) {
    let lines = text.lines().count();
    let words = text.split_whitespace().count();
    let chars = text.chars().count();
    (lines, words, chars)
}

fn main() {
    let args: Vec = env::args().collect();

    if args.len() < 2 {
        eprintln!("Penggunaan: wordcount <file>");
        std::process::exit(1);
    }

    let filename = &args[1];
    let contents = fs::read_to_string(filename)
        .expect("Tidak bisa membaca file");

    let (lines, words, chars) = count_stats(&contents);

    println!("File: {}", filename);
    println!("  Baris : {}", lines);
    println!("  Kata  : {}", words);
    println!("  Karakter: {}", chars);
}

Output:

File: test.txt
  Baris : 1
  Kata  : 2
  Karakter: 11

Langkah 4: Error Handling yang Lebih Baik

Gunakan Result untuk penanganan error yang lebih robust:

use std::env;
use std::fs;
use std::process;

fn count_stats(text: &str) -> (usize, usize, usize) {
    let lines = text.lines().count();
    let words = text.split_whitespace().count();
    let chars = text.chars().count();
    (lines, words, chars)
}

fn main() {
    let args: Vec = env::args().collect();

    if args.len() < 2 {
        eprintln!("Penggunaan: wordcount <file>");
        process::exit(1);
    }

    let filename = &args[1];

    let contents = match fs::read_to_string(filename) {
        Ok(c) => c,
        Err(err) => {
            eprintln!("Error membaca '{}': {}", filename, err);
            process::exit(1);
        }
    };

    let (lines, words, chars) = count_stats(&contents);

    println!("File: {}", filename);
    println!("  Baris  : {}", lines);
    println!("  Kata   : {}", words);
    println!("  Karakter: {}", chars);
}

Langkah 5: Parsing Argumen dengan Struct

Buat struct untuk menangani argument parsing dengan lebih terstruktur:

use std::env;
use std::fs;
use std::process;

struct Config {
    filename: String,
    show_lines: bool,
    show_words: bool,
    show_chars: bool,
}

impl Config {
    fn new(args: &[String]) -> Result {
        if args.len() < 2 {
            return Err("Penggunaan: wordcount <file> [options]");
        }

        let filename = args[1].clone();
        let mut show_lines = true;
        let mut show_words = true;
        let mut show_chars = true;

        for arg in &args[2..] {
            match arg.as_str() {
                "--lines-only" => { show_words = false; show_chars = false; }
                "--words-only" => { show_lines = false; show_chars = false; }
                "--chars-only" => { show_lines = false; show_words = false; }
                _ => {}
            }
        }

        Ok(Config { filename, show_lines, show_words, show_chars })
    }
}

fn count_stats(text: &str) -> (usize, usize, usize) {
    let lines = text.lines().count();
    let words = text.split_whitespace().count();
    let chars = text.chars().count();
    (lines, words, chars)
}

fn main() {
    let args: Vec = env::args().collect();

    let config = Config::new(&args).unwrap_or_else(|err| {
        eprintln!("Error: {}", err);
        process::exit(1);
    });

    let contents = match fs::read_to_string(&config.filename) {
        Ok(c) => c,
        Err(err) => {
            eprintln!("Error membaca '{}': {}", config.filename, err);
            process::exit(1);
        }
    };

    let (lines, words, chars) = count_stats(&contents);

    println!("File: {}", config.filename);
    if config.show_lines { println!("  Baris  : {}", lines); }
    if config.show_words  { println!("  Kata   : {}", words); }
    if config.show_chars { println!("  Karakter: {}", chars); }
}

Jalankan dengan opsi:

cargo run -- test.txt --words-only
cargo run -- test.txt --lines-only

Langkah 6: Unit Testing

Tambahkan test untuk memastikan fungsi count_stats bekerja dengan benar:

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_count_stats() {
        let text = "Hello Rust
Tutorial CLI
";
        let (lines, words, chars) = count_stats(text);
        assert_eq!(lines, 2);
        assert_eq!(words, 4);
        assert_eq!(chars, 24);
    }

    #[test]
    fn test_count_stats_empty() {
        let text = "";
        let (lines, words, chars) = count_stats(text);
        assert_eq!(lines, 0);
        assert_eq!(words, 0);
        assert_eq!(chars, 0);
    }
}

Jalankan test:

cargo test

Langkah 7: Build untuk Release

Setelah selesai, build aplikasi untuk release:

cargo build --release

Binary hasil ada di target/release/wordcount. Bisa langsung dijalankan:

./target/release/wordcount test.txt

Kesimpulan

Kamu baru saja membuat CLI tool pertama dengan Rust! Dari tutorial ini kamu belajar:

• Inisialisasi project dengan Cargo
• Membaca argument dari command-line
• Membaca dan memproses file
• Error handling dengan Result
• Membuat struct dan method
• Unit testing
• Build untuk release

Lanjutkan eksplorasi dengan menambahkan fitur seperti: membaca multiple file, output ke file, progress bar, atau parsing dengan library seperti clap untuk argument parsing yang lebih powerful. Selamat coding!

Rust Lengkap: Dari Dasar hingga Advanced dengan Code Blocks

Mon, 15 Jun 2026 19:31:00 GMT

Artikel ini adalah panduan komprehensif yang membawa kamu dari nol hingga tingkat mahir dalam Rust. Setiap konsep disertai dengan code block yang bisa langsung dicoba, sehingga kamu tidak hanya membaca teori tapi juga melihat cara kerja kode di praktik.

1. Variabel dan Tipe Data

Di Rust, variabel secara default immutable. Gunakan mut untuk membuatnya mutable.

fn main() {
    let name = "Rust";           // &str (string literal)
    let mut count = 0;           // mutable i32
    count += 1;

    let pi: f64 = 3.14159;     // eksplisit tipe
    let is_ok = true;           // boolean
    let letter = 'A';           // char (Unicode)

    let numbers: [i32; 3] = [1, 2, 3];  // array fixed-size
    let tuple = (1, "hello", 3.14);      // tuple

    println!("nama={}, count={}, pi={}, tuple={:?}", name, count, pi, tuple);
}

2. Ownership dan Borrowing

Ownership adalah fondasi Rust. Setiap nilai di heap punya satu owner.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;              // ownership berpindah
    // println!("{}", s1);    // ERROR: s1 tidak valid lagi

    let s3 = String::from("world");
    let len = get_length(&s3); // borrow — tidak mengambil ownership
    println!("{} panjangnya {}", s3, len);  // s3 masih valid
}

fn get_length(s: &String) -> usize {
    s.len()  // pinjam sementara, balikin
}

3. Lifetimes

Lifetime memastikan referensi selalu valid dan tidak dangling.

fn main() {
    let s1 = String::from("abcd");
    let s2 = "xyz";
    let result = longest(&s1, s2);
    println!("String terpanjang: {}", result);
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

Penjelasan: 'a adalah lifetime annotation. Parameter dan return value berbagi lifetime yang sama, jadi compiler memastikan semua referensi valid selama hasil dipakai.

4. Struct dan Enum

struct User {
    username: String,
    email: String,
    active: bool,
}

struct Point(i32, i32, i32); // tuple struct

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let user = User {
        username: String::from("rustacean"),
        email: String::from("hi@rust.dev"),
        active: true,
    };

    let msg = Message::Move { x: 10, y: 20 };
    println!("User {} aktif: {}", user.username, user.active);
}

5. Pattern Matching

Match di Rust memastikan semua kasus ditangani, tidak ada null pointer exception.

enum Coin {
    Penny, Nickel, Dime, Quarter(String),
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("Quarter dari {}!", state);
            25
        }
    }
}

fn main() {
    let coin = Coin::Quarter(String::from("Alaska"));
    println!("Nilai: {}", value_in_cents(coin));

    let some_number = Some(5);
    let absent_number: Option = None;

    match some_number {
        Some(n) => println!("Ada angka {}", n),
        None => println!("Tidak ada angka"),
    }

    // If let — shorthand untuk single pattern
    if let Some(5) = some_number {
        println!("Yup, itu 5!");
    }
}

6. Error Handling — Result dan Option

Rust tidak punya exception. Gunakan Result untuk operasi yang bisa gagal, dan Option untuk nilai yang mungkin tidak ada.

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result {
    let mut file = File::open("hello.txt")?;
    let mut username = String::new();
    file.read_to_string(&mut username)?;
    Ok(username)
}

// Sama dengan versi di atas, tapi lebih ringkas
fn read_username_from_file_short() -> Result {
    std::fs::read_to_string("hello.txt")
}

fn main() {
    match read_username_from_file() {
        Ok(name) => println!("Username: {}", name),
        Err(e) => println!("Error: {}", e),
    }

    let greeting_file_result = File::open("hello.txt");
    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => {
            println!("Gagal buka file: {:?}", error);
            panic!("File diperlukan!");
        }
    };
}

7. Traits dan Generics

Traits seperti interface di bahasa lain. Generics membuat kode reusable.

trait Summary {
    fn summarize(&self) -> String;
    fn summarize_author(&self) -> String;

    // Default implementation
    fn summarize_detail(&self) -> String {
        format!("{}: {}", self.summarize_author(), self.summarize())
    }
}

struct NewsArticle {
    headline: String,
    author: String,
}

struct Tweet {
    username: String,
    content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        self.headline.clone()
    }
    fn summarize_author(&self) -> String {
        self.author.clone()
    }
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        self.content.clone()
    }
    fn summarize_author(&self) -> String {
        self.username.clone()
    }
}

// Generic function dengan trait bound
fn notify(item: &T) {
    println!("Breaking! {}", item.summarize());
}

fn main() {
    let article = NewsArticle {
        headline: String::from("Rust 1.80 Dirilis!"),
        author: String::from("Rust Team"),
    };
    let tweet = Tweet {
        username: String::from("@rustacean"),
        content: String::from("Rust itu keren!"),
    };

    notify(&article);
    notify(&tweet);
    println!("{}", article.summarize_detail());
}

8. Iterators dan Closures

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    // Iterator dengan map dan filter
    let doubled: Vec = v.iter()
        .map(|x| x * 2)
        .collect();
    println!("{:?}", doubled);  // [2, 4, 6, 8, 10]

    // Filter — ambil yang genap
    let evens: Vec<&i32> = v.iter()
        .filter(|x| *x % 2 == 0)
        .collect();
    println!("{:?}", evens);  // [2, 4]

    // Fold — reduce ke single value
    let sum: i32 = v.iter().fold(0, |acc, x| acc + x);
    println!("Sum: {}", sum);  // 15

    // Closure yang menangkap environment
    let threshold = 3;
    let big: Vec<&i32> = v.iter()
        .filter(|x| **x > threshold)
        .collect();
    println!("Bigger than {}: {:?}", threshold, big);

    // Chaining
    let result: Vec = (1..=10)
        .filter(|x| x % 2 == 0)
        .map(|x| x * x)
        .collect();
    println!("Squares of even numbers: {:?}", result);
}

9. Modules dan Crates

Rust memiliki sistem module yang jelas untuk mengatur kode.

// src/lib.rs
mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
        fn seat_at_table() {}
    }
    mod serving {
        fn take_order() {}
        fn serve_order() {}
    }
}

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }
    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast { toast: String::from(toast), seasonal_fruit: String::from("peaches") }
        }
    }
}

pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();
    // Relative path
    front_of_house::hosting::add_to_waitlist();

    let mut meal = back_of_house::Breakfast::summer("Rye");
    meal.toast = String::from("Wheat");
    println!("Saya pesan toast {}", meal.toast);
}

// src/main.rs
use crate::front_of_house::hosting;
fn main() { hosting::add_to_waitlist(); }

10. Concurrency — Threads

Rust membuat concurrency aman secara default berkat ownership.

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap();  // tunggu thread selesai

    // Message passing dengan channel
    use std::sync::mpsc;
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi dari thread");
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Diterima: {}", received);

    // Shared state dengan Mutex
    use std::sync::{Arc, Mutex};
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }
    println!("Result: {}", *counter.lock().unwrap());
}

11. Testing

Rust punya built-in testing framework yang sangat baik.

pub fn add(a: i32, b: i32) -> i32 { a + b }

pub fn divide(a: f64, b: f64) -> Option {
    if b == 0.0 { None } else { Some(a / b) }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 2), 4);
    }

    #[test]
    fn test_add_negative() {
        assert_eq!(add(-2, -3), -5);
    }

    #[test]
    fn test_divide() {
        assert_eq!(divide(10.0, 2.0), Some(5.0));
        assert_eq!(divide(10.0, 0.0), None);
    }

    #[test]
    #[should_panic]
    fn test_panic() {
        panic!("Ini sengaja panic!");
    }

    #[test]
    fn result_with_question_mark() -> Result<(), String> {
        if 2 + 2 == 4 { Ok(()) } else { Err(String::from("dua plus dua bukan empat")) }
    }
}

Jalankan test dengan:

cargo test
cargo test -- --nocapture  # tampilkan output print
cargo test test_add        # jalankan test tertentu

12. Macros

Macros di Rust adalah metaprogramming yang powerful.

// Declarative macro dengan macro_rules!
macro_rules! say_hello {
    () => {
        println!("Hello!");
    };
}

macro_rules! create_function {
    ($func_name:ident) => {
        fn $func_name() {
            println!("Kamu memanggil {:?}", stringify!($func_name));
        }
    };
}

create_function!(foo);
create_function!(bar);

// Procedural macro (contoh sederhana)
// #[derive(Debug)] — menambahkan implementasi trait Debug secara otomatis
#[derive(Debug, Clone)]
struct Person {
    name: String,
    age: u32,
}

fn main() {
    say_hello!();
    foo();
    bar();

    let p = Person { name: String::from("Alice"), age: 30 };
    println!("{:?}", p);  // Debug output

    let p2 = p.clone();
    println!("{:?}", p2);
}

// macro_rules! dengan variadic arguments
macro_rules! vec_of_strings {
    ($($x:expr),*) => {
        {
            let mut temp_vec = Vec::new();
            $( temp_vec.push(String::from($x)); )*
            temp_vec
        }
    };
}

fn use_macro() {
    let v = vec_of_strings!["a", "b", "c"];
    println!("{:?}", v);
}

Kesimpulan

Rust adalah bahasa yang menuntut disiplin dari programmer, tapi imbalannya sangat besar: kode yang aman dari bug memori, aman dari data race, dan performa setara bahasa native. Mulai dari konsep sederhana seperti variabel dan fungsi, hingga topik advanced seperti lifetimes, traits, dan concurrency — Rust menyediakan tool yang jelas dan compiler yang peduli untuk memandu kamu menulis kode berkualitas tinggi.

Jangan berkecil hati dengan pesan error yang panjang dari compiler. Pesan-pesan itu sebenarnya adalah bantuan terbaik yang pernah kamu dapatkan dari compiler mana pun. Baca pesan error dengan teliti, perbaiki, kompilasi ulang, dan teruslah praktik. Semangat rustacean!

Rust dengan Code Preview: Belajar dari Contoh Praktis

Mon, 15 Jun 2026 19:11:00 GMT

Salah satu cara terbaik untuk memahami Rust adalah dengan melihat dan mencoba kode langsung. Artikel ini membawa kamu melewati konsep-konsep fundamental Rust melalui contoh kode yang bisa dicoba langsung.

Hello World — Program Pertama

fn main() {
    println!("Hello, World!");
}

Penjelasan: fn mendeklarasikan fungsi. println! adalah macro (ditandai dengan !) untuk mencetak teks ke konsol. Setiap program Rust dimulai dari fungsi main.

Variabel dan Mutability

fn main() {
    let x = 5;          // immutable — tidak bisa diubah
    let mut y = 10;     // mutable — bisa diubah
    y = y + 5;
    println!("x = {}, y = {}", x, y);
}

Penjelasan: Secara default, variabel di Rust adalah immutable. Gunakan mut agar variabel dapat diubah nilainya. Ini mencegah perubahan tidak terduga.

Ownership — Konsep Inti Rust

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;          // ownership pindah ke s2
    // println!("{}", s1); // ERROR! s1 tidak lagi valid
    println!("{}", s2);  // OK
}

Penjelasan: String::from membuat String di heap. Saat s1 diberikan ke s2, ownership berpindah. Rust tidak mengizinkan dua owner untuk satu data di heap — ini mencegah double-free.

Borrowing dengan Referensi

fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s);
    println!("Panjang '{}' adalah {}.", s, len);
}

fn calculate_length(text: &String) -> usize {
    text.len()
}

Penjelasan: &s membuat referensi terhadap s (borrowing). calculate_length meminjam s tanpa mengambil ownership. Setelah fungsi selesai, s masih valid dan bisa dipakai.

Struct dan Method

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect = Rectangle { width: 30, height: 50 };
    println!("Luas = {}", rect.area());
}

Penjelasan: struct mendefinisikan tipe data kustom. impl menambahkan method pada struct. &self adalah referensi ke instance struct, mirip this di bahasa lain.

Enum dan Pattern Matching

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

fn main() {
    let msg = Message::Move { x: 10, y: 20 };
    match msg {
        Message::Quit => println!("Keluar"),
        Message::Move { x, y } => println!("Pindah ke ({}, {})", x, y),
        Message::Write(text) => println!("Tulis: {}", text),
    }
}

Penjelasan: enum di Rust bisa menyimpan data berbeda untuk setiap variant. match memastikan semua kemungkinan ditangani — tidak ada null pointer exception yang tidak terduga.

Result untuk Error Handling

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt");
    match greeting_file {
        Ok(file) => println!("File berhasil dibuka!"),
        Err(error) => println!("Gagal membuka file: {:?}", error),
    }
}

Penjelasan: Rust tidak punya exception. Sebagai gantinya, fungsi yang bisa gagal mengembalikan Result<T, E>. Kamu wajib menangani kasus Ok dan Err — compiler memastikan tidak ada error yang terlewat.

Kesimpulan

Rust mungkin punya kurva belajar yang curam, tetapi setiap aturan yang ada punya alasan kuat: keamanan memori, keamanan concurrency, dan performa tinggi. Mulailah dari contoh sederhana di atas, jalankan dengan cargo run, dan modifikasi untuk melihat apa yang terjadi. Praktik langsung adalah cara tercepat untuk menguasai Rust.

Mengenal Rust: Bahasa Pemrograman yang Aman dan Performant

Mon, 15 Jun 2026 19:06:00 GMT

Rust telah menjadi salah satu bahasa pemrograman yang paling banyak dibicarakan dalam dekade terakhir. Dikembangkan oleh Mozilla Research dan pertama kali dirilis pada tahun 2010, Rust dirancang untuk mengatasi masalah kritis yang sering dihadapi oleh bahasa pemrograman sistem tradisional seperti C dan C++ — terutama bug terkait memori dan kesulitan dalam menulis kode concurrent yang aman.

Apa Itu Rust?

Rust adalah bahasa pemrograman sistem yang dikompilasi secara statis dengan fokus utama pada tiga pilar: keamanan, kecepatan, dan concurrency. Yang membuat Rust istimewa adalah kemampuannya untuk menjamin keamanan memori pada waktu kompilasi tanpa memerlukan garbage collector. Ini berarti program Rust dapat mencapai performa yang setara dengan C/C++ sambil tetap menghindari masalah umum seperti dangling pointers, buffer overflows, dan data races.

Fitur Utama Rust

Keamanan Memori Tanpa Garbage Collector

Rust menggunakan sistem ownership dan borrowing yang unik. Setiap nilai dalam Rust memiliki owner tunggal, dan ketika owner keluar dari scope, nilai tersebut akan dibersihkan secara otomatis. Borrow checker — komponen compiler Rust — memastikan bahwa referensi ke data selalu valid, sehingga mencegah banyak bug keamanan memori pada tahap kompilasi.

Zero-Cost Abstractions

Rust menganut prinsip zero-cost abstractions, yang berarti fitur-fitur tingkat tinggi seperti iterators, closures, dan generics tidak menambahkan overhead runtime. Apa yang Anda tulis dalam bentuk abstrak akan dikompilasi menjadi kode mesin yang sama efisiennya dengan kode yang ditulis secara manual.

Concurrency yang Aman

Concurrency dalam Rust didesain untuk aman secara default. Sistem ownership mencegah data races karena compiler memastikan bahwa data mutable hanya dapat diakses oleh satu thread pada satu waktu, atau data yang dibagikan bersama adalah immutable. Ini membuat menulis program concurrent dan parallel menjadi jauh lebih mudah dan aman.

Ekosistem yang Berkembang Pesat

Meskipun Rust masih relatif muda, ekosistemnya telah berkembang pesat. Cargo — package manager dan build system bawaan Rust — membuat manajemen dependensi dan kompilasi proyek menjadi sangat mudah. Crates.io, repositori paket Rust, memiliki ribuan library open-source yang mencakup berbagai kebutuhan pengembangan.

Kapan Menggunakan Rust?

Rust adalah pilihan ideal untuk pengembangan sistem operasi dan embedded systems, aplikasi web server dengan performa tinggi, game engine dan real-time systems, blockchain dan cryptocurrency platforms, alat command-line (CLI) yang cepat dan andal, serta WebAssembly untuk performa di browser.

Perusahaan-perusahaan besar seperti Google, Microsoft, Amazon, Meta, dan Discord telah mengadopsi Rust untuk berbagai komponen kritis sistem mereka.

Kesimpulan

Rust menawarkan solusi yang elegan untuk masalah klasik dalam pengembangan perangkat lunak sistem. Dengan kombinasi keamanan memori yang terjamin pada waktu kompilasi, performa setara bahasa native, dan ekosistem yang modern, Rust menjadi pilihan yang menarik baik untuk proyek baru maupun untuk memigrasikan komponen kritis dari sistem yang sudah ada.

Bagi pengembang yang baru memulai, kurva belajar Rust memang terkenal cukup curam — terutama karena konsep ownership dan borrowing. Namun, investasi waktu untuk memahami konsep-konsep tersebut akan membuahkan hasil berupa kode yang lebih aman, lebih cepat, dan lebih mudah dipelihara.

Tutorial Lengkap Armbian - Install dan Konfigurasi Linux untuk ARM Board

Mon, 15 Jun 2026 17:00:00 GMT

Panduan lengkap install Armbian di board ARM seperti Orange Pi, Banana Pi, dan Raspberry Pi. Mulai dari flashing SD card hingga konfigurasi awal sistem.

Tips linux Untuk Pemula

Mon, 15 Jun 2026 07:26:00 GMT

markdown

# Tips Linux untuk Pemula

Berikut adalah beberapa tips yang berguna untuk kamu yang baru mulai menggunakan Linux.

## 1. Kenali Terminal

Terminal adalah senjata utama di Linux. Beberapa perintah dasar:

```bash
ls - list file
cd - ganti direktori
cp - copy file
mv - pindah/renama file
rm - hapus file

2. Update System Rutin

bash

bash

sudo apt update && sudo apt upgrade -y

3. Install Software

bash

bash

sudo apt install nama-aplikasi

Kesimpulan

Linux memang butuh waktu untuk dipelajari, tapi setelah terbiasa kamu akan merasa lebih bebas dan fleksibel.

Panduan Astro Untuk Pemula

Sun, 14 Jun 2026 18:54:00 GMT

markdown

markdown

# Panduan Astro untuk Pemula

Astro adalah framework web all-in-one untuk membangun website yang cepat.

## Apa itu Astro?

Astro memungkinkan kamu membangun website dengan:

- **Zero JavaScript by default** — tidak ada JS yang dikirim ke browser
- **Island Architecture** — hydrate hanya komponen yang interaktif
- **Support semua framework** — React, Vue, Svelte, dll

## Cara Install

```bash
npm create astro@latest

Struktur Project

text

text

src/
├── components/
├── content/
├── layouts/
└── pages/

Kesimpulan

Astro sangat cocok untuk website yang mengutamakan performa dan SEO.

Erlk1m Blog

Tutorial Rust WebAssembly (WASM): Menjalankan Kode Rust di Browser untuk Pemula

Pendahuluan

Prasyarat dan Instalasi Toolchain

Rust dan Cargo

WASM Target

wasm-pack

Langkah 1: Inisialisasi Project Rust

Langkah 2: Konfigurasi Cargo.toml

Langkah 3: Menulis Kode Rust

Langkah 4: Kompilasi ke WebAssembly dengan wasm-pack

Langkah 5: Membuat Antarmuka Web (HTML & JavaScript)

Langkah 6: Menjalankan Local Web Server

Kapan Sebaiknya Menggunakan WebAssembly?

Tips Optimasi Ukuran File WASM

Kesimpulan

Docker: Container untuk Modern Development

ChatGPT: Revolusi Kecerdasan Buatan yang Mengubah Cara Kita Bekerja dan Belajar

test 12345

MiMo V2.5 Pro — Model AI Terkuat Xiaomi yang Menyaingi Frontier Model Dunia

MiMo V2.5 Pro — Model AI Terkuat Xiaomi yang Menyaingi Frontier Model Dunia

Pendahuluan

Spesifikasi Utama

Arsitektur: Hybrid Attention + Mixture-of-Experts

Hybrid Attention

Multi-Token Prediction (MTP)

Benchmark Performa

Artificial Analysis Intelligence Index

Kemampuan Agentic (GDPval-AA)

Benchmark Base Model

Kemampuan Agentic: Bukan Sekadar Chatbot

Studi Kasus: Compiler SysY dalam Rust

Studi Kasus: Video Editor Desktop

Perbandingan dengan Model Lain

Long Context: Performa di 1 Juta Token

Model Keluarga MiMo V2.5

Cara Menggunakan

Via API

Self-Hosting Requirements

Ekosistem dan Integrasi

Kesimpulan

test table

Setup Home Server Lengkap dengan Armbian + Docker Compose

Armbian Server di TV Box Amlogic — Ubah Android TV Box Jadi Linux Server Murah

Armbian Server di TV Box Amlogic — Ubah Android TV Box Jadi Linux Server Murah

Pendahuluan

TV Box Amlogic yang Kompatibel

Chipset yang Didukung Armbian

Cek Chipset TV Box Anda

Alat dan Bahan

Langkah 1: Download Armbian untuk Amlogic

Pilih Image yang Tepat

Langkah 2: Flash Image ke MicroSD

Menggunakan BalenaEtcher

Menggunakan dd (Linux)

Langkah 4: Boot Pertama & Konfigurasi

Proses Boot

Login Default

First Boot Wizard

Langkah 5: Install Armbian ke Internal eMMC (Opsional tapi Direkomendasikan)

Cek eMMC Terdeteksi

Install ke eMMC dengan armbian-install

Langkah 6: Optimasi untuk Server

1. Disable GUI (Jika Install Versi Desktop)

2. Optimasi CPU Governor

3. Disable Bluetooth & WiFi (Jika Tidak Digunakan)

4. Setup Static IP

5. Thermal Management

Langkah 7: Install Docker & Deploy Aplikasi Server

Install Docker

Install Docker Compose

Project 1: File Browser (NAS Ringan)

Project 2: Pi-hole

Project 3: Uptime Kuma (Monitoring)

Troubleshooting Khusus Amlogic

TV Box Boot Loop ke Android

Ethernet Tidak Terdeteksi

HDMI Tidak Keluar Output

Panas Berlebihan & Thermal Throttling

WiFi Tidak Berfungsi

Menggunakan `dd` (Linux)

Install ke eMMC dengan `armbian-install`