Supported languages & sources

Nomain ingests both mainframe estates and modern application codebases, and turns them into navigable knowledge graphs. This page lists exactly what it parses today: the languages, the dialects and column formats, the embedded sublanguages, and the analyses that run on top.

At a glance:

• 5 programming languages (3 mainframe, 2 modern)
• 6 infrastructure and mainframe formats
• 3 embedded sublanguages
• ANTLR grammars for the mainframe, Roslyn and tree-sitter for modern code, plus an AI fallback parser

Mainframe programming languages

Full ANTLR grammar support. The agent treats these as first-class languages: it reads them, builds call and data graphs, and answers questions grounded in their nodes.

COBOL

An IBM Enterprise COBOL superset, a COBOL-85 core extended with COBOL 2002/2014-era features. Fixed-format card-image source (columns 7-72, with sequence and identification areas in columns 73-80) is handled with automatic format detection. Programs, paragraphs, sections, copybooks and declaration members are all distinct graph nodes.

• Numeric usages: COMP-1..5, PACKED-DECIMAL, BINARY, POINTER
• Modern data: JSON, XML, UTF-8, NATIONAL
• COPY / REPLACING with IBM REPLACE semantics; copybook fragments
• CA-Librarian -INC include cards in the sequence area, parsed as copy statements and expanded for cross-file symbol resolution
• Report Writer, Communication Section, CBL/PROCESS compiler directives

Embedded sublanguages: EXEC CICS, EXEC SQL, EXEC DLI (IMS).

Status

Generally available. Grammar v19, copybook v11, dcl v4.

PL/I

IBM mainframe PL/I: external and internal procedures, packages, BEGIN blocks, alternate entries, DECLARE and FILE declarations, and user-defined structures. Fixed-format with MARGINS(2,72); columns 73-80 are treated as the sequence area and stripped.

Embedded sublanguage: EXEC SQL (DB2).

Status

Generally available. Grammar v2.

Easytrieve / Easyplus

Report-writer programs and macros, grammar-parsed from source: activities, procedures, reports, file and record layouts, working fields and control flow. %macro invocations are recognized and their arguments recorded even when the macro library itself was not delivered with the source. Embedded EXEC SQL lands on the same table entities as COBOL, so data lineage crosses the language boundary.

Files named .ezt are always analyzed as Easytrieve; Easytrieve programs that arrive with a COBOL file extension, a common artifact of mainframe dataset extraction, are recognized by their content and analyzed as Easytrieve. A program is also discovered from its JCL invocation, either an EXEC EASYPLUS step or the documented EXEC PGM=EZTPA00 form (and its deprecated EZT / EZTCOM aliases) with the program named by the SYSIN DD's DSN=lib(member), and resolves to the same node the source parse produces.

Status

Available. Parser v2.

Modern application languages

Object-oriented application code, parsed with the same tools the language communities use, so the reader keeps up with current syntax. There is no card-image format here: these are free-form UTF-8 files. Both parsers are error-tolerant, so a file with syntax errors still yields a partial model instead of being dropped, and neither family uses the AI fallback parser. Cross-file references are resolved by name at the end of each analysis; deeper type-resolved precision is on the roadmap.

C# / .NET

Parsed with Roslyn, the official C# compiler front end, in syntax-only mode. Namespaces, classes, structs, records, interfaces, enums and delegates are distinct nodes, down to their methods, constructors, properties, fields and events. .csproj files are read for project structure and project-to-project references, and web controllers and minimal-API routes surface as HTTP endpoints.

Edges include calls, field and property reads and writes, inheritance, interface implementation, overrides, using imports, project references, and dependency-injection bindings: an AddSingleton / AddScoped / AddTransient registration links an interface to its implementation, so a call made through the interface can be followed to the concrete type.

• Source: .cs; project files: .csproj
• Entry points (a program's Main, HTTP endpoints, hosted services, tests) are flagged for reachability

Status

Available. Parser v4. Cross-file resolution is name-based; type-semantic precision is on the roadmap.

JavaScript & TypeScript

Parsed with tree-sitter using the official JavaScript and TypeScript grammars (no Node.js runtime required). TypeScript is handled as a dialect of the same family rather than a separate language, detected from the file extension. Each file becomes a module node, containing its classes, interfaces, enums, type aliases, methods, properties, fields, functions and variables.

Edges include calls, reads and writes, inheritance, interface implementation, overrides, import relationships, and dependency-injection bindings (Angular providers). Front-end HTTP requests are linked across the stack to the .NET endpoint they target, so a call from the browser can be traced to the server code that answers it.

• Source: .ts, .tsx, .js, .jsx, .mjs, .cjs; module resolution reads tsconfig.json

Status

Available. Parser v3. Framework template parsing (such as Angular HTML templates) is deferred.

The mainframe around the code

These are not programming languages, but they are real graph elements: job control, screen maps, system definitions, database schema and scheduler topology. All are grammar-parsed under the mainframe family.

JCL

z/OS Job Control Language. Jobs, steps, cataloged procedures, in-stream and cataloged data, DD statements, and internal-reader job submission: the spine that ties programs to datasets and to each other. A program rarely names itself directly, so Nomain detects the program a step really runs through several invocation patterns, then resolves it to the parsed COBOL, PL/I or Easytrieve node (or to a name-based stub when the source isn't present).

How a program is detected in a step:

Pattern	How the program is found
Direct invocation	EXEC PGM=name
Cataloged procedure	EXEC procname; the programs inside the proc are detected by the patterns below
TSO terminal monitor	IKJEFT01 / IKJEFT1A / IKJEFT1B reading SYSTSIN; the program named by RUN PROGRAM(name) or EXEC 'lib(name)'
IMS region controller	EXEC PGM=DFSRRC00, the application program lifted from its PARM= list
Hybrid-runner procs (e.g. DLIDB2)	program taken from a proc parameter such as MBR=name
DD-sourced runners (EASYPLUS proc; EXEC PGM=EZTPA00 and deprecated EZT / EZTCOM)	program read from the member in a SYSIN DD DSN=lib(member)
Link-edit runner procs (PL1LINK / PLILINK)	PL/I members named in SYSLIN linkage-editor INCLUDE control cards
Internal-reader submission (IEBGENER)	a JCL member copied to SYSOUT=(,INTRDR) is wired as a submitted job

Status

Generally available. Grammar v10.

CICS System Definitions

DFHCSDUP DEFINE statements: resource groups, and the file, program and map definitions that make a CICS region run.

Status

Generally available. Grammar v2.

BMS Screen Maps

Basic Mapping Support macros: DFHMSD / DFHMDI / DFHMDF. Map sets, maps and fields become nodes so the 3270 screen layer is visible in the graph.

Status

Generally available. Grammar v1.

DB2 SQL & DDL

CREATE TABLE / INDEX / PROCEDURE definitions, plus the embedded EXEC SQL found inside COBOL, PL/I and Easytrieve. Grammar lineage tracks DB2 for z/OS v12.

Status

Generally available. Grammar v2.

CA-7 Scheduler

Job-scheduling definitions: the dependency trees and trigger relationships that decide when each job runs. Surfaces cross-job flow that JCL alone can't show. Parsed from the XML and JSON export formats.

Status

Generally available. Grammar v1.

Control-M Scheduler

Scheduler topology from the XML export format (DEFJOB / EMDEF) and the JSON Automation API format: jobs, conditions and triggers.

Status

Generally available. Parser v1.

Recognized, even when not yet parsed

Some languages are spotted by how they're invoked rather than by parsing their source. Nomain still places them in the graph and wires up the edges, so nothing in the runtime topology silently disappears.

Assembler (HLASM)

Identified by a content sniff for DSECT / CSECT. The file is recognized as assembler and skipped rather than mis-parsed.

Status

Detected: recognized and connected, not yet parsed in depth.

REXX / CLIST

Recognized through TSO terminal-monitor invocations (IKJEFT01 with a SYSTSIN DD). Edges are drawn to the program node so the call is preserved.

Status

Detected: recognized and connected, not yet parsed in depth.

Documents

Repository documentation is ingested alongside code. Nomain classifies each file as repository, architecture or process documentation, then summarizes and embeds it for retrieval. Supported formats: .md, .pdf, .docx.

Status

Generally available.

Anything else: the AI fallback parser

Any mainframe or otherwise-unrecognized file that fails deterministic parsing is preserved as a SourceFile node and handed to the AI fallback parser, which extracts nodes and edges marked parsedBy: ai. Coverage degrades gracefully instead of dropping the file. Modern application code is the exception: its parsers are error-tolerant and produce a partial model directly, so those files are not sent to the fallback.

What runs on top of the parse

Parsing is the floor. These analyses turn the syntax trees into a knowledge graph the agent can reason over, and into findings a team can act on.

Analysis	What it produces
AST generation (deterministic)	ANTLR-based parsing of every supported language into abstract syntax trees, the source of truth for everything downstream.
Dependency discovery (deterministic)	Call graphs, copy/include relationships, and file, table, map, job and scheduler dependencies, derived as high-level edges between components. For object-oriented code it also captures inheritance, interface implementation, overrides, dependency-injection bindings, project references, and cross-stack HTTP calls that link a front-end request to the backend endpoint it hits.
Unused-code detection (liveness)	Dead-store analysis over COBOL and PL/I; flags unreachable paragraphs and copybooks a program includes but never references.
AI fallback parsing (parsedBy: ai)	When deterministic parsing can't claim a file, an LLM extracts its structure so coverage degrades gracefully.
Explain functionality (grounded)	Natural-language explanations of what a program or paragraph does, refined for quality and grounded in the graph node it describes.
Business-process extraction (BPMN)	Process models lifted from source and documents (domains, areas, lanes, tasks and gateways) then mapped back onto the code that implements them.

The entities Nomain extracts

Every parsed construct becomes a typed node. The knowledge-graph ontology groups these kinds as follows:

Group	Node kinds
Program structure	Program, Paragraph, Section, Copybook, Procedure, Declarations
Data & files	Data definition, File, File control, File descriptor, Dataset
Jobs & flow	Job, Step, Proc, Proc file, In-stream data
Screens & CICS	Map set, Map, Field, CICS command, Queue
Catalog & DDL	DDL table, DDL index, DDL procedure, Cataloged reference
Object-oriented code	Project, Namespace, Module, Class, Struct, Record, Interface, Enum, Type alias, Delegate, Method, Constructor, Property, Field, Event, Function, Variable, HTTP endpoint

When the agent answers, the nodes it cites are shown as live entity references, so you can trace every claim back to the code that supports it.

Related

• Systems and the knowledge graph
• Ask questions in chat