Developer documentation.

curl -fsSL https://chudflare.com/install.sh | sh

chudflare --version
# => 0.0.1-chud

chudflare login
# => Opening https://chudflare.com/login
# => Token saved. ray=8c0ffee-CHUD-DEN psl=2.1

chudflare init my-slop-site
cd my-slop-site
# project ready. CLI now mews on your behalf.

chudflare deploy
# => bundling slop...                done (412kb)
# => uploading to 310 PoPs...         done
# => cf-ray:    8c0ffee-CHUD-DEN
# => deployed to https://my-slop-site.chuds.dev
# => you may now resume hunching

chudflare verify  # actually fetches a URL and greps for the marker
chudflare badge   # prints the embeddable verified-chud badge HTML
chudflare psl     # WAF classifier (same engine as the web tool)
chudflare dig     # CNS resolver output
chudflare mew     # random mumbled response (do not pipe to prod)
chudflare login   # fake auth, prints your chud ray-id
chudflare init    # writes chudflare.yml
chudflare deploy  # fake deploy logs
chudflare status  # pings the status page
chudflare hunch   # current operator hunch angle (time-varying)

export default {
  async fetch(request, env) {
    return new Response("hello, chud.", {
      status: 200,
      headers: { "x-mog-status": "YOU GOT MOGGED" }
    });
  }
};

// chudscript: same idea, fewer braces, lower frame-rate
@chudder("hello-world")
fn handle(req) {
  slop "hello, chud."
}

# requires the chudflare-python-edge runtime (beta, mewing)
from chudflare import Response, chudder

@chudder("hello-world")
async def handle(request):
    return Response("hello, chud.", headers={"x-mog-status": "YOU GOT MOGGED"})

export default {
  async fetch(request, env) {
    const ua = request.headers.get("user-agent");
    const psl = await env.PSL.score(ua);

    if (psl > 5.5) {
      return new Response("you got mogged.", { status: 403 });
    }

    return env.C2_BUCKET.get("slop.html");
  }
};

// classic.cs
let name = "chud"
const psl = 2.1

fn greet(n) {
  return $"hello, ${n}"
}

if psl < 4 {
  print(greet(name))
}

// multi-exit.cs
@chudder("multi-exit")
fn handle(req) {
  let p = chud req.psl()   // chud = await

  if p > 8   { mog "you got mogged." }
  if p > 5   { mew "go outside." }
  if p < 1   { hunch "internal slop error" }

  slop "hello, chud."
}

import { c2, psl } from "@chudflare/stdlib"

@chudder("api")
@psl_max(5.5)
fn handle(req, env) {
  let bucket = c2.bucket(env.C2_BUCKET)
  let obj = chud bucket.get("slop.html")

  cope {
    slop mew(obj.body)
  } else {
    hunch "couldn't slop the slop."
  }
}

export default {
  async fetch(request, env) {
    const { psl } = await env.CHUD_AI.classify(request);
    return psl > 7
      ? new Response("403 chad detected", { status: 403 })
      : fetch(request);
  }
};

export default {
  async fetch(request) {
    const res = await fetch(request);
    const text = await res.text();
    return new Response(text.toLowerCase(), res);
  }
};

export default {
  async fetch(request) {
    try {
      return await fetch(request);
    } catch {
      return new Response("nothing ever happens", { status: 200 });
    }
  }
};

export default {
  async fetch(request) {
    const ua = request.headers.get("user-agent") || "";
    const tells = ["hayes valley", "founder mode", "agi by eoy"];
    if (tells.some(t => ua.toLowerCase().includes(t))) {
      return new Response("blocked. go outside.", { status: 451 });
    }
    return fetch(request);
  }
};

chudflare c2 create monster-cans
# => bucket "monster-cans" created in DEN-CHUD-3
# => bucket posture: hunched (default)

chudflare c2 put monster-cans/ultra-zero.json \
  --from-file ./drink.json
# => uploaded 1.2kb. eTag: 8c0ffee...
# => chud-cache: HIT (somehow)

const obj = await env.C2_BUCKET.get("ultra-zero.json");
if (!obj) return new Response("nothing ever happens", { status: 404 });
return new Response(obj.body, { headers: { "content-type": "application/json" } });

chudflare cns add \
  --zone example.com \
  --type A \
  --name @ \
  --value 6.9.6.9 \
  --posture hunched
# => record created. ttl=300. posture: hunched

dig @6.9.6.9 chudflare.com
;; ANSWER SECTION:
chudflare.com.    300    IN    A    6.9.6.9
;; QUERY TIME: 73 msec (mewing latency, nominal)

# /etc/chudflare/firewall.toml

[[rule]]
description = "block visible cheekbones"
expression  = "(http.req.psl gt 5.5)"
action      = "mog_back"

[[rule]]
description = "block users mid-mewing"
expression  = "(http.req.tongue_position eq 'palate')"
action      = "chud_challenge"

[[rule]]
description = "allow self only"
expression  = "(ip.src eq cf.user.fat_fucking_chud)"
action      = "allow"

{
  "app": "slop-dashboard.internal",
  "require": [
    { "identity": "sso.chudmaxx.io" },
    { "posture": "hunched" },
    { "psl_max": 4.2 }
  ],
  "deny": [
    { "trait": "jaw_visibility" },
    { "trait": "unprompted_sigma_post" }
  ]
}

curl https://api.chudflare.com/v4/user \
  -H "Authorization: Bearer chud_live_8c0ffee..."

curl -X POST https://api.chudflare.com/v4/zones \
  -H "Authorization: Bearer chud_live_8c0ffee..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "example.com",
    "jurisdiction": "agartha",
    "posture": "hunched",
    "plan": "chud"
  }'

curl -X POST https://api.chudflare.com/v4/zones/$ZONE/firewall/rules \
  -H "Authorization: Bearer chud_live_..." \
  -d '{
    "description": "block visible cheekbones",
    "expression": "(http.req.psl gt 5.5)",
    "action": "mog_back"
  }'

{
  "success": true,
  "errors": [],
  "messages": ["chud-ray: 8c0ffee-DEN-3"],
  "result": {
    "id": "chud_...",
    "created_on": "2026-05-18T01:50:00Z",
    "posture": "hunched"
  }
}

pip install https://chudflare.com/sdk/chudflare-4.0.0.tar.gz

from chudflare import Chudflare

client = Chudflare(api_token="chud_live_8c0ffee...")

# create a zone
zone = client.zones.create(
    name="example.com",
    jurisdiction="agartha",
    posture="hunched",
    plan="chud",
)
print(f"created zone {zone.id} (ray: {zone.ray})")

# add a firewall rule
client.firewall.rules.create(
    zone_id=zone.id,
    description="block visible cheekbones",
    expression="(http.req.psl gt 5.5)",
    action="mog_back",
)

npm install https://chudflare.com/sdk/chudflare-4.0.0.tgz
# or, if you've taken the bait:
bun add https://chudflare.com/sdk/chudflare-4.0.0.tgz

const { Chudflare } = require("chudflare");

const client = new Chudflare({ apiToken: "chud_live_8c0ffee..." });

const zone = await client.zones.create({ name: "example.com" });
console.log(`created zone ${zone.id} (ray: ${zone.ray})`);

const verdict = await client.verify({ url: "https://my-slop-site.com" });
console.log(verdict);
// => { ok: true, marker: "meta", ray: "8c0ffee-CHUD-...", psl: 2.1, ... }

curl -L -o chudflare-go.zip https://chudflare.com/sdk/chudflare-go-4.0.0.zip
unzip chudflare-go.zip
# then in your go.mod:
#   require chudflare.com/chudflare-go v4.0.0
#   replace chudflare.com/chudflare-go => ./chudflare-go-4.0.0

package main

import (
  "context"
  "fmt"

  chudflare "chudflare.com/chudflare-go"
)

func main() {
  client := chudflare.New("chud_live_8c0ffee...")
  zone, err := client.Zones.Create(context.Background(), "example.com")
  if err != nil {
    panic("you got mogged: " + err.Error())
  }
  fmt.Printf("created zone %s (ray: %s)\n", zone.ID, zone.Ray)
}