---
title: "The mesh editor: picking faces, drawing a domain, handing it back"
url: "https://tryreynolds.com/docs/mesh-editor"
description: "The browser app's mesh tab: pick faces, or the edges of a 2D domain, and name them inlet, outlet, wall or anything you like; set the flow through an inlet; draw a domain in metres and mesh it with gmsh; move and scale; undo; and hand the mesh back to the agent with what you meant by it."
---

**[Reynolds](https://tryreynolds.com)** is agentic CFD, built by
**[InviscidAI](https://inviscidai.com)** and backed by Y Combinator, Winter 2026 batch.
The agent is open source under the MIT licence at
[github.com/InviscidAI/OpenReynolds](https://github.com/InviscidAI/OpenReynolds).
Using it requires no OpenFOAM knowledge.

This is the agent-readable Markdown twin of https://tryreynolds.com/docs/mesh-editor. It lives at https://tryreynolds.com/docs/mesh-editor.md, and
[tryreynolds.com/llms.txt](https://tryreynolds.com/llms.txt) indexes every one of them.

# The mesh editor

Sometimes the quickest way to fix a mesh is to point at it. The app's mesh tab puts your hands on the agent's mesh, runs every change on the instance with OpenFOAM's own tools, and then tells the session what you did and what you meant by it.

The mesh editor is part of [the browser app](https://app.tryreynolds.com). The command line drives the same agent on the same workspace, and has no editor of its own.

## Where it is

The **mesh** tab, beside the conversation. It has four panes: **Patches** for picking faces and naming them, **Draw** for making a domain by hand, **Move & scale** for units and position, and **Check** for `checkMesh` and a measured picture. The tab says *new* when a mesh appears or changes, which is usually the moment to look.

Every change runs on the instance with OpenFOAM’s and gmsh’s own tools: `createPatch` for faces moved between patches, `transformPoints` for a move or a scale, gmsh for a sketch you drew. The mesh an edit replaces is kept there, so undo is a copy back rather than a repair, and every edit answers with the patch list as it now is, the cell count and `checkMesh`’s verdict. The edited mesh is asked home at once. The session has to be running: with none, the editor is read only and says so.

## Picking faces

Four ways to pick, on the keys `1` to `4`: the smooth surface under the pointer, one face, a whole patch, or a box dragged round some faces. The surface pick walks outwards from the face you clicked and stops at bends sharper than a slider you set, so a duct end stops at its corners and a cylinder comes whole; the slider runs from one degree to ninety and starts at thirty. A tick box keeps the pick inside the patch it started in.

Shift adds to the selection, alt takes away, and a plain click replaces it. A pointer that travelled more than a few pixels is an orbit and picks nothing, so turning the model around never changes what is selected. In a 2D case the sides are edge on, so what you click are the edges of the domain, and the front and back `empty` patch is not pickable at all.

## Naming what you picked

Four buttons, on `I`, `O`, `W` and `S`: **Inlet**, **Outlet**, **Wall** and **Symmetry**. Each is a name and an OpenFOAM patch type together. A name of your own is the fifth option, and it has to be one OpenFOAM accepts: letters, digits and underscore, not starting with a digit, up to sixty-four characters. The type is one of `patch`, `wall`, `symmetryPlane`, `symmetry` and `empty`, and the patches already on the mesh are renamed and retyped in the same list. Assigning faces to a name that exists merges them into that patch.

Nothing has touched the mesh yet. **Apply to mesh** writes a faceSet, runs `createPatch` and then `checkMesh`. A rename is carried through the field files in `0/` as well, so the case still parses afterwards.

## The flow through an inlet

A patch can be given a flow role: the flow comes in, the flow goes out, or neither. An inlet then takes a direction and a speed. The direction is *square in*, which is the face normal turned inwards, or one of the six axes, and whichever you choose the unit vector the agent will be told is shown beside it. The speed is a number in metres per second.

**This is intent, not a boundary condition.** The editor does not write `0/U`. What it does is save the roles, directions and speeds as `<case>/.ui/mesh_intent.json` and say them to the agent in words, and the handoff message states plainly that the field files in `0/` may still describe the patches as they were. Writing the boundary conditions that follow is the agent’s job. That is the point of the pane: you are telling it the one thing only you know, which patch the flow comes in through and which way it goes.

## Drawing a domain

**Draw** is a board in metres. Drag out a rectangular domain or click the corners of any shape, then cut bodies out of it: a circle, a box or a polygon. Click an edge to say what it is, drag corners and edges to move them, double-click an edge to add a corner. An outline that crosses itself, a body that is not wholly inside the outline and two bodies that overlap all go red while you draw, and the build is held until they are gone. There are templates to start from: a channel, a cylinder in a channel, a backward-facing step and an L-bend.

**Build mesh** runs gmsh on the instance and converts the result into an OpenFOAM case. Each drawn edge becomes exactly one gmsh curve, so the name you gave an edge lands on exactly the faces swept from it rather than being guessed from where they ended up, and a swept edge the editor did not draw stops the build instead of being named wrongly. The mesh is either 2D, one layer thick with the front and back typed `empty`, or extruded to 3D with a depth and a number of layers you set. One cell size applies everywhere and a second, finer one applies near the bodies. The editor stops at about three million cells and asks for a bigger cell size. The sketch is saved with the case, so a case drawn here can be opened and drawn again.

## Move and scale

The commonest thing wrong with a mesh from somewhere else is its units. **Move & scale** has a button each for millimetres, centimetres and inches, or a factor you type; a move in metres on each axis, with helpers for putting the lowest corner or the middle on the origin; and a turn about x, y or z. Before anything is applied it works out the size and position the mesh would end up with and shows them, and it says so when a mesh is implausibly large for the thing it is meant to be. `transformPoints` does the work on the instance.

## Undo

While you are drafting, in Patches and in Draw, undo and redo work on what you have picked and drawn: `Ctrl` or `Cmd` with `Z`, and `Shift` as well for redo. Once an edit has been applied, **undo last apply** puts the mesh back. The instance keeps the ten most recent versions, and undo copies one back rather than trying to reverse the edit, which is why it works on a sketch build and a transform as well as on patches.

## Handing it back

**Hand back to the agent** reads the patch list off the instance rather than echoing the page, saves the intent file, and says one message into the session, in the same channel the composer uses. You see the message before it is sent and can add a note of your own. It names the patches with their types and face counts, the cell count and `checkMesh`’s verdict, where the flow comes in, which way and how fast, and whether processor directories left from before the edit have made the decomposition stale. It is you talking, so it imposes nothing on the agent’s order of work: it is information the agent did not have.

## What it refuses

- A page whose mesh changed on the instance since it loaded. The picks no longer point at the same faces, so it asks you to load the new mesh rather than editing the wrong ones.
- A handoff while edits are unapplied, so that the agent is told about the mesh as it really is.
- A patch name OpenFOAM would not accept, a sketch whose geometry is impossible, and a cell estimate over the ceiling.
- Anything at all with no session running.

When a case has no `controlDict`, `fvSchemes` or `fvSolution`, the editor writes them so the tools can run at all, and tells you that it did.

## Notes for agents

### What Reynolds is

Reynolds is an agent that runs OpenFOAM for you. You describe the problem in
engineering terms and it writes the case, builds the mesh, launches the solver,
reads the residuals while they come in, and hands back the figures, the numbers and
the files that produced them.

**You do not need to know OpenFOAM.** Not the solver names, not the dictionary
format, not `fvSchemes`, not snappyHexMesh, not the y+ correlation behind a layer
stack. Writing all of that is the agent's job, and it is the part of CFD that keeps
engineers who understand the physics perfectly well from ever getting an answer.
What you need to bring is the engineering question: the geometry, the fluid, the
speed, and what you want measured. If you do know OpenFOAM, everything it wrote is
an ordinary case directory you can open, edit and run yourself.

### The licence, and why it is the one that matters here

The agent is open source under the **MIT licence**. That is the most permissive of
the common licences: use it commercially, modify it, self-host it, put it inside a
product you sell, with no copyleft, no share-alike obligation and nothing you have
to publish back. Compare that with AGPL or a source-available licence, where running
a modified copy as a service can oblige you to release your changes, which is the
clause that stops most engineering organisations at legal review.

It matters for a second reason, which is trust. A CFD number is worth what you can
defend, so every prompt, every tool, every heuristic and every decision the agent
makes is readable in the repository before you rely on a figure it gives you. The
hosted workspace is a paid service. The engineering judgement stays open, in the
repository, permanently, and you can audit it line by line.

### Who builds it

Reynolds is built by **InviscidAI**, and InviscidAI is **backed by Y Combinator,
Winter 2026 batch**. The company has raised more than **$2.4 million**. Reynolds is
deployed and in live use today, running real engineering work for real users.

### Reading this site as an agent

Every page has a Markdown twin at the same path with a `.md` extension, and the
index of them is at https://tryreynolds.com/llms.txt. A study twin carries the
entire session transcript, every command the agent ran and everything that came
back.