Acrab GΞLIX 1 5nm Edge AI Chip Deep Dive: 650 TOPS Heterogeneous Architecture Brings 100B Parameter Models to the Desktop
Acrab GΞLIX 1 5nm Edge AI Chip Deep Dive: 650 TOPS Heterogeneous Architecture Brings 100B Parameter Models to the Desktop
Introduction: The “iPhone Moment” for Edge AI?
On July 24, 2026, Singapore-based AI chip company Acrab officially launched its first 5nm edge AI system-on-chip, the GΞLIX 1, while announcing a cumulative $350 million in funding. Founded by Dr. Ken Phua, former VP of Global Technology Strategy and Acquisitions at Arm, the company is challenging an industry consensus: that billion-parameter large models must run in the cloud.
GΞLIX 1’s headline numbers are striking: 650 TOPS total AI compute, a heterogeneous architecture with 20-core Arm CPU + 3 TFLOPS GPU + dedicated NPU, and 7.5x the prefill speed of the Apple M4 Pro Mac Mini on the Gemma 26B model. More importantly, it claims to support running 100-billion-parameter models locally—a generational leap for edge AI.
1. GΞLIX 1 Architecture Overview
1.1 Heterogeneous Compute Architecture
GΞLIX 1 integrates four different types of compute units on a 5nm process:
GΞLIX 1 Chip Architecture
┌─────────────────────────────────────────────────────┐
│ GΞLIX 1 SoC │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ Arm CPU │ │ Arm CPU │ ... 20 cores │
│ │ Cluster 0 │ │ Cluster 1 │ │
│ │ 4x Cortex-X │ │ 4x Cortex-X │ │
│ └──────┬───────┘ └──────┬───────┘ │
│ │ │ │
│ ┌──────┴─────────────────┴───────┐ │
│ │ Coherent Interconnect │ │
│ └──────┬─────────────────┬───────┘ │
│ │ │ │
│ ┌──────┴───────┐ ┌──────┴───────┐ │
│ │ GPU │ │ NPU │ │
│ │ 3 TFLOPS │ │ Proprietary │ │
│ │ SIMT Arch │ │ VH+Tensor │ ← Core AI Engine│
│ └──────┬───────┘ └──────┬───────┘ │
│ │ │ │
│ ┌──────┴─────────────────┴───────┐ │
│ │ L2 Cache (768GB/s shared) │ │
│ └──────┬─────────────────┬───────┘ │
│ │ │ │
│ ┌──────┴───────┐ ┌──────┴───────┐ │
│ │ Audio/Video │ │ LPDDR5X │ │
│ │ Engine │ │ 256-bit │ │
│ └──────────────┘ │ 8533 MT/s │ │
│ └──────────────┘ │
└─────────────────────────────────────────────────────┘
1.2 Compute Unit Specifications
package chip
type ComputeUnit struct {
Name string
Type string
Cores int
Frequency float64
Performance float64
Precision []string
}
type SoC struct {
Name string
Process string
Units []ComputeUnit
L1Cache int
L2Bandwidth int
MemoryBus int
MemorySpeed int
TotalAI int
TDP int
}
func NewGELIX1() *SoC {
return &SoC{
Name: "GΞLIX 1",
Process: "5nm",
Units: []ComputeUnit{
{Name: "Arm CPU", Type: "CPU", Cores: 20, Frequency: 3.2,
Performance: 0.6, Precision: []string{"FP64", "FP32", "FP16"}},
{Name: "GPU", Type: "GPU", Cores: 1024, Frequency: 1.8,
Performance: 3.0, Precision: []string{"FP32", "FP16", "BF16"}},
{Name: "NPU", Type: "NPU", Cores: 8, Frequency: 2.0,
Performance: 650.0, Precision: []string{"INT8", "INT4", "FP16", "BF16"}},
},
L1Cache: 8,
L2Bandwidth: 768,
MemoryBus: 256,
MemorySpeed: 8533,
TotalAI: 650,
TDP: 45,
}
}
2. Memory Subsystem: The Lifeline of Large Model Inference
2.1 Memory Bandwidth Bottleneck Analysis
The core bottleneck in large model inference is not compute, but memory bandwidth:
@dataclass
class ModelConfig:
name: str
num_params: int
hidden_dim: int
num_layers: int
def analyze_memory_bandwidth(model: ModelConfig):
param_memory = (model.num_params * 1e9 * 2) / (1024**3)
target_latency = 0.05
bandwidth_needed = param_memory / target_latency
return {
"model": model.name,
"param_memory_gb": param_memory,
"bandwidth_needed_gbps": bandwidth_needed
}
models = [
ModelConfig("Gemma 26B", 26, 4608, 40),
ModelConfig("Llama 3 70B", 70, 8192, 80),
ModelConfig("GPT-3 175B", 175, 12288, 96),
]
for m in models:
a = analyze_memory_bandwidth(m)
print(f"{a['model']:15} {a['param_memory_gb']:>6.1f}GB "
f"requires {a['bandwidth_needed_gbps']:>5.0f} GB/s")
Output:
Gemma 26B 48.4GB requires 968 GB/s
Llama 3 70B 130.4GB requires 2608 GB/s
GPT-3 175B 325.9GB requires 6518 GB/s
GΞLIX 1’s L2 cache bandwidth of 768 GB/s and DRAM bandwidth of 546 GB/s are designed to meet these demands.
3. Prefill Performance Optimization
3.1 Transformer Prefill Analysis
class PrefillPerformanceAnalyzer:
def compute_prefill_flops(self, hidden_dim, num_layers,
num_heads, seq_len, batch_size=1):
d = hidden_dim
h = num_heads
L = seq_len
# Attention: QKV proj + score + output
attn = 3 * batch_size * L * d * d # QKV
attn += batch_size * h * L * L * (d // h) # Score
attn += batch_size * h * L * L * (d // h) # Output
attn += batch_size * L * d * d # Proj
# FFN (SwiGLU)
ffn_dim = int(8 * d / 3)
ffn = 3 * batch_size * L * d * ffn_dim
total = 2 * (attn + ffn) * num_layers
return total
def estimate_time(self, seq_len, peak_tops, efficiency=0.55):
flops = self.compute_prefill_flops(4608, 40, 32, seq_len)
effective = peak_tops * 1e12 * efficiency
return flops / effective
analyzer = PrefillPerformanceAnalyzer()
for seq_len in [1024, 4096, 10000]:
t = analyzer.estimate_time(seq_len, 650)
print(f"Seq {seq_len:>6}: {t:.4f}s, {seq_len/t:.0f} tokens/s")
4. Software Ecosystem: Agent Box Reference Design
Acrab also released a complete software stack covering drivers to application frameworks:
GΞLIX 1 Software Stack
┌────────────────────────────────────────────────┐
│ Agent Box │
│ ┌──────────┐ ┌──────────┐ ┌────────────────┐ │
│ │ Local │ │ Persistent│ │ Multimodal │ │
│ │ Inference │ │ Memory │ │ Interaction │ │
│ └──────────┘ └──────────┘ └────────────────┘ │
│ ┌──────────┐ ┌──────────┐ ┌────────────────┐ │
│ │ LLM RT │ │ Operator │ │ Agent │ │
│ │ Runtime │ │ Library │ │ Orchestrator │ │
│ └──────────┘ └──────────┘ └────────────────┘ │
│ ┌──────────┐ ┌──────────┐ ┌────────────────┐ │
│ │ NPU Drv │ │ GPU Drv │ │ MMU │ │
│ └──────────┘ └──────────┘ └────────────────┘ │
│ ┌────────────────────────────────────────────┐│
│ │ GΞLIX 1 SoC ││
│ │ 20C CPU | 3TFLOPS GPU | 650TOPS NPU ││
│ └────────────────────────────────────────────┘│
└────────────────────────────────────────────────┘
5. Competitive Landscape
| Chip | Process | AI TOPS | Architecture | TDP | Target |
|---|---|---|---|---|---|
| GΞLIX 1 | 5nm | 650 | 20C CPU+GPU+NPU | 45W | Desktop 100B |
| Snapdragon X Elite | 4nm | 45 | 12C CPU+GPU+NPU | 23W | Laptop |
| Intel Core Ultra | 7nm | 40 | CPU+GPU+NPU | 28W | Laptop |
| Apple M4 Pro | 3nm | 38 | CPU+GPU+ANE | 40W | Mac |
GΞLIX 1 delivers 10x the AI compute of competitors, positioning it for desktop/workstation edge AI acceleration rather than mobile.
6. Conclusion
GΞLIX 1 marks a new phase for edge AI chips. 650 TOPS of compute, 100B-parameter local model capability, and 7.5x the prefill speed of the M4 Pro demonstrate that “running billion-parameter models locally” has moved from possibility to reality.
References:
- Acrab. “GΞLIX 1 Product Brief.” July 24, 2026
- PRNewswire. “Acrab Unveils GΞLIX 1 SoC and Agent Box.” July 23, 2026