By Risersoft

FormulaCAD Language

FCL — the language behind FormulaCAD

FCL is a text-first, declarative language for describing parts, assemblies, and drawings.

Instead of hiding design intent in dialogs and files, FCL expresses the model directly in text — and FormulaCAD builds real CAD geometry from it.

FCL makes CAD deterministic, reviewable, reusable, and AI-authorable.

Browse sample components Join waitlist
FCL example · component references
child name=Column key="EN.IPE200"
    span=3000

child name=Beam key="EN.IPE200"
    span=6000
    .translate = ((0, 0, 3000))

The idea in one minute

FormulaCAD is cloud-native parametric CAD.

The unit of work is not a file — it is a component:

  • identified by a key
  • defined by inputs
  • built from an FCL body

You do not manage local CAD files. You reference components by key, and the cloud resolves the model.

FCL is the language inside each component.

Core model

Components, not files

Most CAD systems revolve around files. You open a file, edit it, save it, and pass it around.

FormulaCAD revolves around components.

A component is a cloud object with:

  • a key — its global identifier
  • declared inputs — the parameters you control
  • an FCL body — the geometry definition

You don’t import or copy geometry. You reference components by key, and the platform resolves and composes them at build time.

Define locally. Reference globally.

What this changes

  • Single source of truth — update a component once, and every assembly that references it updates
  • No file duplication — reuse happens by reference, not by copy
  • Shared libraries — components live in your tenant’s namespace and are available to your team
  • Composable assemblies — models are built by referencing components, not importing files
  • Standard by name — call sections like EN.IPE200 directly

This is closer to how modern cloud tools work: you reference objects, not files.

Feature-style modeling in text
params plate_len=100, plate_wid=50, plate_thk=10

sketch name=base
    rect p1=(0,0) p2=($plate_len,$plate_wid) mode=2p
endsketch

extrude profile=#base distance=$plate_thk mode=add

Modeling approach

From feature tree to text

If you have used SolidWorks, Fusion, Creo, or Onshape, the mental model will feel familiar.

A part still has sketches, features, parameters, and references.

The difference is that the feature tree is written directly in text. Every feature references earlier geometry explicitly, and every dependency is visible.

Composition

Assemblies by composition

Assemblies in FCL are built with child rules.

A child references another component by key, passes inputs to it, and places the resulting geometry using ordered placement operations.

These operations — such as .translate, .rx, .ry, .rz — are applied in sequence, making placement explicit and predictable.

This creates a composition graph, not a file hierarchy.

One definition can drive many instances. Updates flow through the assemblies that reference it.

Assembly composition with placement
params bay_count=4, bay_pitch=1500
params beamProfile="EN.IPE200"

child name=Beam key=$beamProfile
    span=6000

child name=Bracket key="bracket_v1" qty=$bay_count
    .translate = ((($index - 1) * $bay_pitch, 0, 0))

Deterministic

The same FCL produces the same geometry.

Inputs, references, and operations are explicit.

Reviewable

FCL is readable text.

Dimensions, features, and references can be inspected directly.

AI-authorable

FCL is structured enough for AI to generate, but constrained enough to validate.

Language boundaries

Declarative by design

FCL avoids general-purpose programming constructs such as:

  • statement-level loops like for or while
  • statement-level if/else blocks
  • mutation
  • side effects
  • recursion

You describe geometry — you do not execute procedures.

CAD-specific patterns instead

FCL still supports the patterns CAD models need:

  • repetition through qty and $index
  • expression-level selection through functions such as @Choose(...) or @If(...)
  • ordered placement operations for predictable transforms

This is a deliberate trade. It keeps models predictable, easier to review, safer to validate, and better suited for AI generation.

Parametric logic

Functions and expressions

FCL encodes engineering logic through parameters, expressions, and typed functions.

Functions are:

  • defined in a central catalog
  • validated at build time
  • deterministic and reusable

Examples:

  • @SinDeg(deg)
  • @CosDeg(deg)
  • @Max(value1,value2)
  • @If(condition,value_if_true,value_if_false)
  • @CurvePlane(CurveName)
Parameters and expressions
params bay_count=4, span=6000
params pitch=@($span / ($bay_count - 1))

child name=Column key="EN.IPE200" qty=$bay_count
    span=3000
    .translate = ((($index - 1) * $pitch, 0, 0))

child name=Beam key="EN.IPE200"
    span=$span
    .translate = ((0, 0, 3000))

A minimal example

Everyday FCL

A typical FCL component mixes local geometry with references to standard components.

You define what is unique, and reference what already exists in the library.

That’s the core pattern.

Define locally. Reference globally.

Browse full examples →
Minimal FCL example
params plate_len=600, plate_wid=400, plate_thk=20

part name=BasePlate
    sketch name=base
        rect p1=(0,0) p2=($plate_len,$plate_wid) mode=2p
    endsketch
    extrude profile=#base distance=$plate_thk mode=add
endpart

child name=Column key="EN.IPE200"
    span=3000

Text-based CAD landscape

Where FCL sits

Text-first CAD is a growing and proven category. Tools like OpenSCAD, CadQuery, and other scripting-based systems show that defining geometry in code is a powerful idea.

FCL builds on the same foundation — but is designed for practical, everyday CAD use.

Instead of script-driven, file-based workflows, FCL is declarative, component-oriented, and cloud-native:

  • models are described in structured text, not built through execution flows
  • reuse happens through component references, not file imports
  • assemblies are composed in a shared runtime, not assembled from local files

The result is a system that keeps the strengths of text-based CAD — clarity, versionability, automation — while aligning with how mechanical CAD is actually used in practice.

Open reference materials

Open grounding corpus

The FCL specification, rule catalog, function library, examples, and standard-library source are published on GitHub.

Use the corpus to:

  • understand FCL
  • audit the library
  • ground your own AI workflows
  • contribute corrections and extensions

The language implementation and FormulaCAD platform remain proprietary. The grounding materials and library source are open reference materials.

View the FCL grounding corpus on GitHub

GitHub is the publication channel

The cloud database is the runtime.

You author components in FormulaCAD. GitHub is where the public specification, examples, and library source can be inspected, used for AI grounding, and improved through review.