Documentation Index
Fetch the complete documentation index at: https://docs.monolex.ai/llms.txt
Use this file to discover all available pages before exploring further.
Performance Benefits
MonoTerm’s Atomic State system dramatically reduces the amount of data processed for each terminal update.The Big Picture
┌───────────────────────────────────────────────────────────────────────┐
│ │
│ PERFORMANCE AT A GLANCE │
│ │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ │ │
│ │ 99.95% │ │
│ │ ┌─────────────┐ │ │
│ │ │ │ │ │
│ │ │ LESS │ │ │
│ │ │ DATA │ │ │
│ │ │ SENT │ │ │
│ │ │ │ │ │
│ │ └─────────────┘ │ │
│ │ │ │
│ │ When you type, MonoTerm sends 99.95% less data than │ │
│ │ traditional terminals │ │
│ │ │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────┘
Data Reduction Visualized
┌───────────────────────────────────────────────────────────────────────┐
│ │
│ WHEN YOU TYPE ONE CHARACTER │
│ │
│ │
│ BEFORE (Traditional): │
│ │
│ ####################################################################│
│ ####################################################################│
│ ####################################################################│
│ ####################################################################│
│ ####################################################################│
│ │
│ ~50 KB sent │
│ (entire screen data) │
│ │
│ │
│ AFTER (Smart Diff): │
│ │
│ # │
│ │
│ ~0.5 KB sent │
│ (only changed line) │
│ │
│ │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 50 KB ═══════════════════════════════════════════→ 0.5 KB │ │
│ │ │ │
│ │ 100x SMALLER │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────┘
What Changes When You Type
┌────────────────────────────────────────────────────────────────────────┐
│ │
│ TYPING "Hello" IN YOUR TERMINAL │
│ │
│ │
│ Your terminal screen (40 rows): │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 1: $ cd my-project │ unchanged │
│ │ 2: $ npm install │ unchanged │
│ │ 3: Done! │ unchanged │
│ │ 4: $ vim file.txt │ unchanged │
│ │ 5: │ unchanged │
│ │ ... │ unchanged │
│ │ 35: │ unchanged │
│ │ 36: │ unchanged │
│ │ 37: │ unchanged │
│ │ 38: │ unchanged │
│ │ 39: $ Hello_ │ <- CHANGED!│
│ │ 40: │ unchanged │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ │
│ Traditional approach: "Send ALL 40 rows every keystroke" │
│ -> 40 rows x 120 cols = 4,800 cells │
│ -> ~50 KB per keystroke │
│ │
│ Smart Diff approach: "Only send row 39 (the changed one)" │
│ -> 1 row x 120 cols = 120 cells │
│ -> ~0.5 KB per keystroke │
│ │
│ │
│ SMART DETECTION │
│ │
│ Only changed rows are detected and sent │
│ │
└────────────────────────────────────────────────────────────────────────┘
Three Modes of Operation
┌───────────────────────────────────────────────────────────────────────┐
│ │
│ THREE MODES OF OPERATION │
│ │
│ │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ MODE 1: FULL │ │
│ │ │ │
│ │ When: Major screen changes (opening vim, running ls) │ │
│ │ │ │
│ │ ┌─────────────────┐ │ │
│ │ │#################│ │ │
│ │ │#################│ All rows sent │ │
│ │ │#################│ Full refresh │ │
│ │ │#################│ │ │
│ │ └─────────────────┘ │ │
│ │ │ │
│ │ Data: ~50 KB │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ MODE 2: PARTIAL (DiffHint) │ │
│ │ │ │
│ │ When: Small changes (typing, cursor movement) │ │
│ │ │ │
│ │ ┌─────────────────┐ │ │
│ │ │.................│ │ │
│ │ │.................│ Only changed rows │ │
│ │ │#################│ <- this row changed │ │
│ │ │.................│ │ │
│ │ └─────────────────┘ │ │
│ │ │ │
│ │ Data: ~0.5 KB (99% less!) │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ MODE 3: NONE │ │
│ │ │ │
│ │ When: Only cursor position changed (blinking) │ │
│ │ │ │
│ │ ┌─────────────────┐ │ │
│ │ │.................│ │ │
│ │ │.................│ Nothing sent! │ │
│ │ │.................│ Just cursor update │ │
│ │ │.................│ │ │
│ │ └─────────────────┘ │ │
│ │ │ │
│ │ Data: ~0.1 KB (99.9% less!) │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────┘
Real-World Scenarios
┌───────────────────────────────────────────────────────────────────────┐
│ │
│ HOW MUCH DATA IS SAVED IN DIFFERENT SCENARIOS? │
│ │
│ │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ SCENARIO 1: Writing code (typing) │ │
│ │ │ │
│ │ Traditional: #################################### 50 KB │ │
│ │ MonoTerm: # 0.5 KB │ │
│ │ │ │
│ │ Savings: 99% │ │
│ │ │ │
│ │ For 1000 keystrokes: │ │
│ │ Traditional: 50 MB │ │
│ │ MonoTerm: 0.5 MB │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ SCENARIO 2: Cursor blinking (idle) │ │
│ │ │ │
│ │ Traditional: #################################### 50 KB │ │
│ │ MonoTerm: . 0.1 KB │ │
│ │ │ │
│ │ Savings: 99.9% │ │
│ │ │ │
│ │ For 1 minute of blinking (~60 blinks): │ │
│ │ Traditional: 3 MB │ │
│ │ MonoTerm: 6 KB │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ SCENARIO 3: Running 'ls' (full screen update) │ │
│ │ │ │
│ │ Traditional: #################################### 50 KB │ │
│ │ MonoTerm: #################################### 50 KB │ │
│ │ │ │
│ │ Savings: 0% (full updates are still full) │ │
│ │ │ │
│ │ BUT: This happens rarely compared to typing! │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────┘
Battery and Resource Impact
┌───────────────────────────────────────────────────────────────────────┐
│ │
│ WHY LESS DATA = BETTER PERFORMANCE │
│ │
│ │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ THE CHAIN REACTION │ │
│ │ │ │
│ │ │ │
│ │ Less data sent │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ Less processing needed │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ Less GPU work (fewer pixels to redraw) │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ Less battery used │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ Cooler laptop │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ Longer work sessions │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
│ │
│ ┌────────────────────────┐ ┌────────────────────────┐ │
│ │ │ │ │ │
│ │ TRADITIONAL │ │ MONOTERM │ │
│ │ │ │ │ │
│ │ Hot laptop │ │ Cool laptop │ │
│ │ Battery drains │ │ Battery lasts │ │
│ │ Fan spinning │ │ Fan quiet │ │
│ │ │ │ │ │
│ └────────────────────────┘ └────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────┘
Memory Efficiency
┌───────────────────────────────────────────────────────────────────────┐
│ │
│ MEMORY ALLOCATION COMPARISON │
│ │
│ │
│ Traditional: Creates new memory for EVERY update │
│ ───────────────────────────────────────────────── │
│ │
│ Update 1: [####] allocate │
│ Update 2: [####] allocate [....] garbage │
│ Update 3: [####] allocate [....] garbage [....] garbage │
│ Update 4: [####] allocate [....] garbage [....] garbage [....] g│
│ │
│ │ │
│ Garbage Collector kicks in │
│ │ │
│ PAUSE! │
│ │
│ │
│ MonoTerm: Reuses memory when possible │
│ ───────────────────────────────────────── │
│ │
│ Update 1: [####] allocate (FULL mode) │
│ Update 2: [####] reuse <- same memory │
│ Update 3: [####] reuse <- same memory │
│ Update 4: [####] reuse <- same memory │
│ │
│ │ │
│ No garbage created! │
│ │ │
│ SMOOTH! │
│ │
│ │
│ Result: No GC pauses = smoother experience │
│ │
└───────────────────────────────────────────────────────────────────────┘
Summary Table
┌───────────────────────────────────────────────────────────────────────┐
│ │
│ PERFORMANCE SUMMARY │
│ │
│ ┌───────────────────┬───────────────────┬───────────────────┐ │
│ │ METRIC │ TRADITIONAL │ MONOTERM │ │
│ ├───────────────────┼───────────────────┼───────────────────┤ │
│ │ │ │ │ │
│ │ Data per │ ~50 KB │ ~0.5 KB │ │
│ │ keystroke │ │ (99% less) │ │
│ ├───────────────────┼───────────────────┼───────────────────┤ │
│ │ │ │ │ │
│ │ Data per cursor │ ~50 KB │ ~0.1 KB │ │
│ │ blink │ │ (99.9% less) │ │
│ ├───────────────────┼───────────────────┼───────────────────┤ │
│ │ │ │ │ │
│ │ Memory │ Every frame │ Full mode only │ │
│ │ allocation │ │ (reused) │ │
│ ├───────────────────┼───────────────────┼───────────────────┤ │
│ │ │ │ │ │
│ │ GC pressure │ HIGH │ ELIMINATED │ │
│ │ │ │ │ │
│ ├───────────────────┼───────────────────┼───────────────────┤ │
│ │ │ │ │ │
│ │ Screen flicker │ POSSIBLE │ ELIMINATED │ │
│ │ │ │ │ │
│ ├───────────────────┼───────────────────┼───────────────────┤ │
│ │ │ │ │ │
│ │ Battery impact │ HIGH │ LOW │ │
│ │ │ │ │ │
│ └───────────────────┴───────────────────┴───────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────┘
DiffHint Optimization
The DiffHint system (Full, Partial, None) intelligently selects the minimum data transfer needed for each update, achieving up to 99.95% reduction in data transfer.