What if programming logic wasn't something you read—but something you walked through?

The Problem

In Glide, we didn't have a good UI for constructing complex conditional expressions. You could have multiple comparisons and AND all of them together, or OR all of them—but that's as complex as it got.

Consider a column called "is qualified" with this logic: something's qualified if it's paid AND the balance is zero OR less than a thousand OR over a million AND override is false. Looking at this, Jason made a good observation: "I don't understand the grouping of what is being ANDed and what is being ORed." The indentation looks like code, but the structure is confusing.

This got me thinking: how would we express this if we didn't have text editors?

Grid Conditions

I created a concept called Grid Conditions—boolean algebra inside a grid interface, visualized as a maze you navigate.

Here's how it works:

  • True evaluates like walking through a hallway. The cell draws a black floor with an opening on the right side, and you emerge to continue.
  • False means you fall through the floor into the alligator lava.

AND as Sequence

If you know your truth tables, you know AND is only true if both operands are true. In Grid Conditions, AND creates a long hallway—a sequence where both terms must be true for you to emerge at the final value.

  • If the first term is false, you fall into the lava.
  • If the second term is false, you fall into the lava.
  • Only if both are true do you make it through.

OR as Parallel Paths

OR works differently. Instead of putting things in sequence, it puts them in parallel. When you OR two terms, the result is true unless both terms are false.

Because you have parallel hallways, you can always go through to the final stage if at least one path is open. But if both terms are false, both hallways have walls blocking the exit, and you drop into the lava.

Why It Works

The visualization is admittedly "pretty alien to look at," but it has a key advantage: you can put your finger on the screen and trace through the maze to evaluate the expression. You see exactly where you end up.

This makes it easier to understand and evaluate than a structured text-based version—especially for people who aren't comfortable with traditional programming syntax.