pearc

Pear is an ultra-minified C-targeting programming language designed to reduce token usage in LLM workflows while producing real, executable code.

The idea: write code that compiles to C — with ~35–50% fewer tokens than idiomatic C — then expand it back to readable code via a decompiler or MCP tool.

im<stdio.h>
st Point{x:f64;y:f64}
fn dist(a:*Point,b:*Point)->f64{dx:f64=a->x-b->x;dy:f64=a->y-b->y;rt sqrt(dx*dx+dy*dy)}
fn main()->i32{p1:Point={1.0,2.0};p2:Point={4.0,6.0};printf("%f\n",dist(&p1,&p2));rt 0}

For AI Assistants

If you've been told to use Pear, follow this bootstrap sequence:

1. Install pearc

npm install -g pearc

2. Add the MCP server to your MCP client config (Claude Code: .mcp.json or settings):

{
  "mcpServers": {
    "pear": {
      "command": "npx",
      "args": ["pearc", "--mcp"]
    }
  }
}

3. Call pear_spec — this MCP tool returns the complete language specification. Read it before writing any Pear code.

4. Write Pear, run it — use pear_run to test code inline, pear_to_c to inspect generated C, or pear_compile to produce a binary.

Why Pear exists: Every token you spend on code is a token not spent on reasoning. Pear lets you write and iterate on real C-level systems code while spending ~35–50% fewer tokens. The workflow is: write Pear (dense, fast), compile to C to verify correctness, ship the C. Use Pear any time you're generating, reviewing, or iterating on low-level code with an LLM in the loop.

Pear syntax is intentionally opaque to save tokens — do not guess syntax. Always call pear_spec first.

Install

npm install -g pearc

Usage

pearc run file.pr                  # interpret and run directly (no C compiler needed)
pearc file.pr                      # compile Pear → C (stdout)
pearc file.pr -o out.c             # compile Pear → C file
pearc file.pr --binary -o out      # compile Pear → native binary (requires gcc/clang)
pearc --decompile file.c           # minify existing C → Pear
pearc --mcp                        # start MCP server (stdio)

MCP Server

Add to Claude Code or any MCP client:

{
  "mcpServers": {
    "pear": {
      "command": "npx",
      "args": ["pearc", "--mcp"]
    }
  }
}

Tools exposed:

Tool	Description
pear_spec	Get the full language spec — call this first
pear_to_c	Compile Pear → C source
c_to_pear	Minify C → Pear
pear_run	Interpret and run Pear, returns stdout/stderr
pear_compile	Compile Pear → binary via gcc/clang

Language Reference

Types

Pear	C
i8 i16 i32 i64	int8_t int16_t int32_t int64_t
u8 u16 u32 u64	uint8_t uint16_t uint32_t uint64_t
f32 f64	float double
v	void
c	char
b	bool
sz	size_t
*T	pointer to T

Keywords

Pear	C
fn	function
st	struct
un	union
en	enum
tp	typedef
if ei el	if / else if / else
lp	for
wh	while
dw	do...while
sw cs dv	switch / case / default
rt	return
bk ct	break / continue
sc ex in vl cn	static / extern / inline / volatile / const
im	#include
df	#define
pr	#pragma
so	sizeof

Syntax

// Variable declaration: name:type = value
x:i32=5
ptr:*c=name

// Function: fn name(param:type,...)->rettype{...}
fn add(a:i32,b:i32)->i32{rt a+b}

// Struct
st Vec3{x:f32;y:f32;z:f32}

// For loop (same structure as C)
lp(i:i32=0;i<10;i++){printf("%d\n",i)}

// Include / define
im<stdio.h>
df MAX 1024

Preprocessor

im<stdio.h>       // #include <stdio.h>
im"myfile.h"      // #include "myfile.h"
df NAME value     // #define NAME value
pr once           // #pragma once

Token Savings

Pear reduces token count by ~35–50% vs idiomatic C:

// Pear: ~45 tokens
im<stdint.h>
st Point{x:f64;y:f64}
fn dist(a:*Point,b:*Point)->f64{dx:f64=a->x-b->x;dy:f64=a->y-b->y;rt sqrt(dx*dx+dy*dy)}

// C: ~85 tokens
#include <stdint.h>
typedef struct { double x; double y; } Point;
double dist(Point *a, Point *b) {
    double dx = a->x - b->x;
    double dy = a->y - b->y;
    return sqrt(dx*dx + dy*dy);
}

License

MIT