Pseudocode anyone can read, with just enough structure for tools and AI to read it too: a typed header, CALL lines for APIs and STEP markers that carry keys. Every logic and flow in Rabbinatix exports as FPC, which the app calls text steps.
There is no single global standard for pseudocode. The best-known conventions are textbook styles and the exam-board specifications used in schools, with keywords like IF … THEN … ELSE … END IF. They are made for people: they have no types, no API calls, and no way to map a line back to what it came from.
FPC keeps that familiar keyword style and adds only what a round trip with tools and AI needs:
A typed header
INPUT and OUTPUT in the same compact shape syntax as the endpoint editor.
CALL lines for APIs
CALL AuthService POST /api/v2/login WITH { … }: which system, which contract.
STEP markers with keys
The app's own keys, so a line maps back to the logic or node it came from.
A small, strict grammar
Readable by anyone who has seen textbook pseudocode, parsed without guessing, easy for an AI to write from one page.
FPC doesn't depend on any language or vendor. It is open: anyone may write, read or build tools for it. We don't claim it is already a standard; we publish it so others can adopt it.
A quick example
A sign-in flow. The first two lines say which FPC it follows and what it describes; then come its inputs, outputs and steps.
user-login.fpc
1FPC1.02FLOW"User login"KEYFLOW-AUTH-LOGIN-001VERSION1.3.03INPUTemail:string(email),password:string,rememberMe?:boolean4OUTPUTtoken:string,expiresIn:integer56STEPLOGIC-AUTH-LOGIN-001/CHK"Inputs valid?"7IFemailISEMPTYORpasswordISEMPTYTHEN8FAIL400"email is required"9ENDIF1011STEPLOGIC-AUTH-LOGIN-001/CALL12result←CALLAuthServicePOST/api/v2/loginWITH{email,password}13IFresult.status=401THEN14FAIL401"Invalid credentials"15ENDIF16RETURN{token:result.body.accessToken,expiresIn:result.body.expiresIn}
Keywords are UPPER CASE and every block ends with END. Indentation is for people.
← sets a value (type <- if you like); = compares.
-- starts a comment.
Construct reference
Every construct, generated from the same table the parser uses. The node types show which logic nodes each one writes; every node in the catalogue has an FPC form.
Document
Header
Every document starts with the FPC version, then what it describes: a FLOW (several systems) or one LOGIC. KEY is the app's key; VERSION or REVISION says which version it came from.
Typed inputs and outputs in the compact shape syntax. `?` marks an optional field, `| null` a nullable one. Endpoint logic reads its request as `request` and may name outputs by HTTP status (`OUTPUT 200: { … }, 401: { error: string }`).
A section of the document carrying one of the app's keys, so tools can map lines back to objects. A step runs until the next STEP. In a FLOW each step is one logic; unknown or missing keys mean "new".
Syntax
STEPkey["title"][INsystem]
Example
STEPLOGIC-AUTH-LOGIN-001"Sign in"INAuthService
Comment
From `--` to the end of the line. Comments never change meaning.
Syntax
-- text
Example
-- exported 2026-09-30 12:00 UTC
Data
Set
Gives a variable (or a field or item of one) a value. `SET` may be left out; `<-` is the ASCII form of `←`.
Syntax
SETtarget←expressiontarget←expression
Example
SETtotal←total+line.price*line.quantity
Nodes: data.setVar, data.getVar, obj.set
Values
Strings, numbers, booleans, null, objects and lists. `{ email }` is short for `{ email: email }`.
Ends the logic with its outputs. Endpoint logic returns an HTTP status and a body. Other logic that reaches its end without RETURN returns {} (its text shows no RETURN line, as it has no Return step).
A value chosen by a condition; the parentheses are required.
Syntax
(IFconditionTHENaELSEb)
Example
SETlabel←(IFcount=1THEN"item"ELSE"items")
Nodes: data.select
Functions
The named functions of the node catalogue (see the function list). Unknown names are errors.
Syntax
name(argument,…)
Example
IFNOTisEmail(lower(trim(email)))THEN
Operators
Operator
ASCII
Meaning
←
<-
assignment (in SET)
OR
logical or
AND
logical and
NOT
logical not (prefix)
=
==
equal (deep for lists and objects)
≠
!=
not equal
<
less than
≤
<=
less or equal
>
greater than
≥
>=
greater or equal
IN
membership in a list
IS [NOT] EMPTY
null, "", [] or {} (postfix)
IS [NOT] NULL
null or missing (postfix)
+
add, or join two strings
-
subtract (and prefix minus)
*
multiply
/
divide (fails on zero)
%
remainder
Reserved words (upper case only): FPC FLOW LOGIC KEY VERSION REVISION SYSTEM ON REQUEST EVENT SCHEDULE INPUT OUTPUT STEP SET IF THEN ELSE END MATCH CASE FOR EACH IN FROM TO REPEAT TIMES WHILE DO CALL WITH EMIT TRY CATCH FINALLY RETRY BACKOFF AS SUCCESS FAILURE PARALLEL BRANCH WAIT RETURN HEADERS FAIL LOG BREAK CONTINUE AND OR NOT IS EMPTY NULL TRUE FALSE
Functions
The node catalogue's named functions. Any other name is an error, so a typo is caught, not guessed.
Values
default(value, fallback) → any
value, or fallback when value is null
exists(value) → boolean
the path exists (the value may be null)
found(value) → boolean
a query found something (not null, not an empty list)
compare(a, b) → integer
-1, 0 or 1
typeOf(value) → string
string, integer, number, boolean, object, array or null
Objects
get(object, "path") → any
a nested value by path (`a.b[0].c`); null when missing
calls a Custom Code function; its JavaScript stays in the logic (deps.code.<name> in exported code)
now() → string(date-time)
current date-time; a new value each time
uuid() → string(uuid)
a new id each time
random(min, max) → integer
integer between min and max
Types
INPUT and OUTPUT use the compact shape syntax of the endpoint editor: string, number, integer, boolean, null, any, a format in brackets like string(email), enum(a, b), objects in braces, T[] for a list, ? for an optional field and | null for a value that may be null.
Endpoint logic reads its request as request and may name its outputs by HTTP status: OUTPUT 200: { token: string }, 401: { error: string }, returned with RETURN 200 WITH { token }.
CALL, STEP and keys
CALL AuthService POST /api/v2/login WITH { body }
A call through an API contract: the system, the method and the path, exactly as the contract says. The result has status, body and headers, so you MATCH on result.status. Databases, queues and external services use their operation name: CALL UsersDb users.findByEmail WITH { email }; events are sent with EMIT.
CALL LOGIC LOGIC-LIB-LINE-TOTAL-001 WITH { item }
Runs other logic by its key: a reusable function, or, in a FLOW, the next system's logic. The API it goes through is kept as a comment.
STEP LOGIC-AUTH-LOGIN-001 "Sign in" IN AuthService
A section with one of the app's keys. A FLOW is a sequence of steps across systems, one per logic. Keys are how tools map lines back to objects: keep them exactly as they are. A step with an unknown key, or with none, means "new".
LOGIC "Sign in" KEY LOGIC-AUTH-LOGIN-001 VERSION 1.3.0
Every export says which object it came from and which version: its named version when the current revision has one, otherwise REVISION n, plus the export time as a comment.
Copy to AI
No AI runs inside Rabbinatix: use the assistant you already have. The workflow is copy and paste.
Step 1
Copy the text steps
In the logic editor's Code panel, Text tab (its … menu), or a flow's Text steps panel: Copy as text steps or Download text steps (.fpc).
Step 2
Add the cheat sheet
Paste the one-page cheat sheet with it, so the assistant knows the rules and the functions.
Step 3
Ask for your language
"Implement this FPC in TypeScript", or "convert my code to FPC 1.0", then check the answer with the validator below.
FPC and your AI assistant in Rabbinatix
Connect the AI assistant in your editor to Rabbinatix and it reads and writes logic and flows as FPC itself: no prompts to copy, no replies to paste.
Ask your assistant
With a key of your own (Integrations → AI assistants), your assistant gets the FPC of any logic or flow, writes code from it in your project, or turns your code into FPC, checks and tests it, and leaves it as a draft. You review the diff and accept it. How it works.
Is my code in step?
Paste a generated file's header, or the FPC your code was written from. You see whether it matches the current version and what changed since, and can ask your assistant to update the code for exactly those changes: a small edit instead of a rewrite.
Validator
Paste FPC to check it as you type. Problems show their line and column; valid FPC is shown in its tidied form. Nothing leaves your browser.
3 errors
For editors: a TextMate grammar for syntax highlighting (VS Code and others) ships in the repository under tools/fpc-vscode.
Every document names its FPC version on its first line: FPC 1.0.
Minor versions (1.1, 1.2…) only add: new statements or functions. A 1.x document without them is valid 1.0; a 1.0 reader warns about a newer minor version.
A major version (2.0) may change meaning, and a 1.x reader refuses it.
Conformance levels: Level 1 tools export valid FPC (read only). Level 2 tools also import it back (round trip), keeping keys.
Licence
The spec: CC BY 4.0
Share and adapt it for any purpose, including commercial, as long as you give credit.
The reference parser: MIT
The lexer, parser, validator and printer are plain TypeScript with no dependencies. Use them in your own tools.