Better Tradeoffs for the AI Era

AI has changed the economics of software: teams can produce more code, faster, and with less oversight. The hard parts are trust and quality. That's where Blorp comes in.

Trust

Pure Code Can't Drop Your Database

Pure functions can transform data, but they cannot perform I/O, mutate global state, call impure functions, or launch tasks. If code can touch the outside world, that boundary is visible.

pure func process_text(text: String) -> String:
	-- This pipeline may be large, but it's pure, so we don't
	-- have to worry about surprising IO like data exfiltration or
	-- dropping a database.
	long_complicated_text_processing_pipeline(text)

Part of trusting code is being able to reason about it. Blorp favors explicitness and low ceremony, so humans and agents can reason about the code in front of them. Value semantics, method chains, explicit failure, exhaustive matches, and more make Blorp code easy to grok -- whether you're coming from Python, TypeScript, Rust, Go, or other modern languages.

pure func parse_port(raw: String) -> Option[Int]:
	-- No exception path: bad input returns `None`.
	raw
		.trim()
		.parse_int()


pure func valid_port(port: Int) -> Bool:
	port >= 1 and port <= 65535


pure func describe_port(raw: String) -> String:
	match parse_port(raw):
		Some(port):
			if valid_port(port):
				"port ${port} is ready"
			else:
				"port ${port} is out of range"
		None:
			"not a number"


func main(args: List[String]) -> Void:
	print(describe_port(" 8080 ")) -- prints: port 8080 is ready
	print(describe_port("70000")) -- prints: port 70000 is out of range
	print(describe_port("oops")) -- prints: not a number

Smaller Surface, Fewer Problems

Blorp excludes many footguns, while keeping expressiveness and performance high. The result is many failure classes are entirely removed, like buffer overflows, out-of-bounds access, null pointer exceptions, use-after-free, double-free, unchecked tensor shapes, and unhandled match cases.

Quality

Good structure feels natural in Blorp, so agents and humans are more likely to produce code worth keeping.

Model the Domain with Ease

Records, unions, and exhaustive pattern matching make illegal states harder to express. Correctness starts in the model, not in scattered defensive checks.

union Build:
	Queued
	Running(Int)
	Passed
	Failed(String)


pure func status_label(build: Build) -> String:
	match build:
		Queued: "queued"
		Running(percent): "running ${percent}%"
		Passed: "passed"
		Failed(reason): "failed: ${reason}"


func main(args: List[String]) -> Void:
	print(status_label(Running(42))) -- prints: running 42%

Imperative Shell, Functional Core

Keep effects close to the program boundary. Keep decisions in pure functions that take plain values and return plain values.

import:
	system: read_file


record ReleaseReport {
	checks: Int,
	blockers: Int
}


pure func non_empty(line: String) -> Bool:
	line.trim() != ""


pure func is_blocker(line: String) -> Bool:
	line.contains("BLOCKER")


pure func build_report(raw: String) -> ReleaseReport:
	checks: List[String] = raw
		.lines()
		.filter(non_empty)

	{
		checks = checks.length(),
		blockers = checks
			.filter(is_blocker)
			.length()
	}


pure func format_report(report: ReleaseReport) -> String:
	if report.blockers == 0:
		"ready: ${report.checks} checks passed"
	else:
		"blocked: ${report.blockers} of ${report.checks} checks need review"


func main(args: List[String]) -> Int:
	-- Imperative shell: file I/O, printing, and exit codes stay near the boundary.
	match read_file("release-checks.txt"):
		Ok(raw):
			-- Functional core: parsing and release decisions stay pure.
			report = format_report(build_report(raw))
			print(report) -- prints: "blocked: 1 of 3 checks need review"
			0
		Err(message):
			print_error(message)
			1

Helpful Compiler Feedback

Compiler errors point humans and agents in the right direction. Blorp tries to show the problem and explain the fix, so code moves from idea to application faster.

error: Pure function 'greet' cannot call impure function 'print'
  --> review.brp:2:2
   |
 2 | 	print(name)
   | 	^^^^^^^^^^^
   |
   = note: 'print' is impure because it performs I/O
   = help: Remove 'pure' from the function signature, or use a pure alternative

Native Performance

Blorp compiles to native code and uses automatic reference counting (no GC) for reliable performance. Optimized memory management keeps Blorp within range of C for many workflows.