About Forthix

Get to the Essence of a System

Our Philosophy

The Question

How do we truly understand complex systems?

Our Path

Understanding the fundamental relationships that define a system. Category theory gives us the language to think about relationships; Forthic gives us the syntax to express them in code.

Core Virtues

Relationships Come First

Understanding emerges from seeing relationships, not from isolated parts.

Category theory is primarily about relationships between things. It's the mathematical foundation of studying how things connect, transform, and compose.

In practice, this means:

  • • Asking "how does A relate to B?" before "how do I implement this?"
  • • Thinking in morphisms (transformations that preserve structure)
  • • Seeing composition patterns across different domains

The Key Relationship: Transformation

Transformation is the relationship we work with most in software.

Every time you write code that derives B from A, you're expressing a transformation. Category theory calls these morphisms.

Morphisms capture:

  • • "I can compute B from A" (when A has enough information)
  • • "This transformation preserves certain properties"
  • • "These transformations compose in predictable ways"

This isn't just theory—it's what you already do. Category theory makes it precise.

Solve Problems by Understanding Relationships

Solutions emerge when you grasp the essential relationships.

Don't hack around problems. Understand the system's structure—the morphisms that define it—and design from there.

This means:

  • • Identifying what information exists and what transformations are possible
  • • Finding where information is lost or preserved
  • • Building architectures that reflect the problem domain

Why Forthic?

It's About Essence, Not Syntax

Forthic isn't about a preference for stack-based syntax.

It's about creating the simplest, most essential way to express categorical concepts in code.

Most languages express composition through awkward syntax: 

compose(f, g)
g(f(x))
x |> f |> g

In Forthic, composition IS concatenation: 

f g  # Morphisms compose naturally

This isn't novelty—it's making categorical thinking effortless.

Four Design Principles

1. Composition is built-in

String concatenation = morphism composition. Category theory becomes natural.

2. Morphisms are first-class

Every word is a morphism. Every program is a composition.

3. Information flow is visible

The stack shows what information exists at each step.

4. The category grows with you

Define new words = add new morphisms. The coding category adapts to your domain.

5. Multi-runtime by design

Wrap your existing code in any language—Python, JavaScript, Ruby, and more. Forthic runs everywhere. One program can orchestrate multiple systems in different languages seamlessly.

6. Built for AI collaboration

LLMs generate Forthic that wraps YOUR code, not generic APIs. No servers, no egress—just concise, explainable transformations you execute locally.

An architectural alternative to server-based approaches like MCP.

Forthic is a perfect fit for the application of categorical thinking to real programming problems.

Categorical Coding

What It Means

Categorical Coding is a way of thinking about software that puts relationships first.

Instead of asking:

  • "How do I implement this?"
  • "What data structure should I use?"
  • "What's the algorithm?"

We ask:

  • "Does A contain enough information to compute B?"
  • "Is this transformation reversible?"
  • "How do these relationships compose?"

The Three Foundations

Category Theory

The mathematics of relationships. Gives us morphisms, functors, and adjoints.

Information Theory

Measures what's possible. Information theory tells us if A contains enough information for B.

Executable Code (Forthic)

Makes it real. Turn abstract relationships into programs you can run.

Wrap. Compose. Abstract.

The three-step philosophy of Categorical Coding with Forthic:

1

Wrap Your Existing Code

Forthic doesn't replace your codebase—it wraps it. Build modules around YOUR existing systems in any language. Your domain logic stays where it is. You just create a Forthic interface to it.

2

Compose Transformations

Chain wrapped operations together using Forthic's concatenative composition. Because Forthic is multi-runtime, one program can orchestrate Python code, JavaScript services, Ruby systems—all seamlessly.

3

Abstract Higher-Level Vocabularies

Create domain-specific languages that express business logic directly. LLMs can then generate programs using your vocabulary—programs that are concise, readable, and execute across your entire stack.

The Result:

You build on what you have, not from scratch. LLMs generate orchestration code that's transparent, auditable, and runs locally—no servers, no network complexity, complete control.

Our Mission

A platform where categorical thinking is practice, not just theory.

Through Forthic notebooks, real-world applications, and a growing community, we're making it possible to:

  • Build software that preserves information and adapts gracefully
  • Learn categorical concepts through hands-on practice
  • Transform how we think about software architecture

We're not just writing code differently—we're thinking differently about what good code should be.

Who This Is For

For developers building with AI

Let LLMs generate Forthic that wraps YOUR codebase—no servers needed. One program, multiple runtimes, complete transparency.

An architectural alternative to MCP that emphasizes control and simplicity.

For programmers curious about category theory

You've heard it's powerful but found it too abstract. We teach it through code.

For engineers dealing with complex systems

Categorical thinking reveals the essential structure beneath complexity.

For teams building maintainable software

Shared vocabulary around relationships and information flow improves design.

For anyone who thinks there's a better way

If traditional abstraction feels like it loses something important, you're right—and there's an alternative.

Frequently Asked Questions

Do I need to know category theory?

No. We start from zero through practical examples.

Do I need advanced math?

No. If you can code, you can learn categorical thinking.

Why a new language?

Forthic makes categorical concepts natural to express in code. It was designed to around transformations, composition, and abstraction.

Is this practical or theoretical?

Both. It solves real problems: APIs, pipelines, provenance, privacy.

How long does it take?

Like any skill, it develops over time. Start with the blog series.