Skip to content
L-Workshop / research index www.l-workshop.my.id

L-Workshop

Language Workshop

We work on visual notation, structured interaction, compiler pipelines and executable semantics.

A research workshop on visual and block-based programming languages and compiler construction — building languages and tools that make program structure directly inspectable.

VPLvisual language design
ASTstructured representation
IRintermediate models
CODEcompiler output
The MNL environment, with declaration and expression blocks annotated by callouts showing each block's type and value.

MNL — blocks annotated with their type and value

01 / About the workshop

A visual editor is not decoration around a language. It is part of the language architecture.

L-Workshop — Language Workshop — is a research workshop on visual and block-based programming languages and compiler construction. It designs languages where the notation itself carries grammar and type information, and builds the compiler paths that take those notations to running code.

Seven projects are developed here: block-based languages and front ends for functional and object-oriented programming, a notional machine for C, and GraphLambda, a graph-native functional language whose source stays fixed during execution. Each project is published on its own domain.

02 / Project index

Seven projects, seven domains.

Every project runs on its own subdomain of l-workshop.my.id.

A block-based functional programming language built for programming education. It visualizes computational processes — beta reduction, function evaluation — and uses visual means to carry semantic information: shape represents grammar, color indicates value type.

block-based functional type inference program visualization YAKI compiler

Read the MnL help 8 chapters · v5.2.0

Looking for the older MnL? mnl-legacy.l-workshop.my.id · legacy docs

Block Lambda

B-Lambda

A compact visual environment for composing lambda expressions and inspecting reduction and evaluation as explicit steps.

lambda calculus reduction evaluation

Read the B‑Lambda help 7 chapters · v1.0.0

A visual programming environment and compiler path that preserves structural intent while translating Blockly programs into readable MiniJava source.

Blockly MiniJava AST code generation

Read the B‑MJ help 7 chapters

Visual SML

ViSML

A block-based front end for Standard ML, and the setting for the workshop’s work on how much of a textual grammar’s structure survives its transformation into blocks.

Standard ML grammar transformation block syntax

Read the ViSML help 7 chapters · v5.0.0

A block-based treatment of Featherweight Java, the core calculus for class-based object-oriented languages, developed alongside Block MiniJava.

Featherweight Java object calculus block syntax

Read the BFJ help 7 chapters

Mirror-C

Mirror-C

A block-based notional machine for a fragment of C. Build a program as blocks, then step it and watch the stack, the heap and the pointer edges between them — the picture is computed by the same machine that produces the output, and is proved faithful to it.

C notional machine pointers & memory

Read the Mirror-C help 7 chapters

A statically typed, higher-order visual functional language with a persistent source graph. Typed ports, directed wires and nested regions express functions, sharing and recursion; a source-anchored debugger steps execution without rewriting the program.

graph-native higher-order functions static typing SAVAM

Read the GraphLambda help 8 chapters

03 / Research threads

What the workshop is actually studying.

Eight threads run across the projects. Each one is grounded in a working environment rather than a specification alone.

01 MNL

Reactive environments

Every edit is answered immediately: the environment returns the result of evaluation, or the error, while the program is still being built.

Reactive blocks
02 MNL · B-Lambda · B-MJ · ViSML · BFJ

Shape and color as semantics

The block-based projects use grammar-aware Blockly renderers with distinct connector shapes and category colors. GraphLambda uses typed SVG ports and wire geometry to distinguish integers, Booleans and function values.

Shape and color
03 MNL

Type inference and typing suggestions

Types are inferred rather than declared, and candidate types are offered in place, aligned with the constraints of the surrounding term.

Type system
04 MNL · B-Lambda · B-MJ · BFJ

Evaluation strategies, cross-checked

Call-by-value and call-by-structure reduction shown step by step in MNL; independently implemented evaluators — substitution, abstract machines, even a register VM — run in lockstep elsewhere to test that they agree.

Program visualization
05 MNL · B-Lambda · B-MJ · ViSML · BFJ

Text ⇆ blocks, structure preserved

The block-based projects connect written and visual forms, from live text-to-block parsing to a block–AST correspondence BFJ has proved as a theorem. GraphLambda also compiles typed λG text into its persistent source graph.

Visual SML
06 B-MJ

Aliasing, made visible

The same B-MJ program runs under two value models side by side — one heap-referenced, one copy-on-write — so where object assignment aliases, and where it doesn’t, becomes something you can watch.

Value models
07 MNL / YAKI

Compiler interfaces

YAKI, the Yet Another Compiler Interface, converts block-based MNL into text-based languages including SML and Scala, and writes MNL’s typing derivations.

Compiler
08 GraphLambda

Source-anchored execution

The source graph stays fixed while the abstract machine advances. SAVAM observations expose focus, transition rules and effects; runtime values and closures link back to the source nodes, ports and regions that anchor them.

GraphLambda debugger
Compiler route

From workspace to target code

Each stage preserves language structure while moving from interactive visual construction to a target program.

01 / input

Visual blocks

Typed connections express a grammar-constrained program.

02 / model

Workspace model

Block relations become a normalized intermediate structure.

03 / ast

Abstract syntax

Language rules are validated in a target-independent tree.

04 / output

Target code

Readable source is emitted from the validated program — MiniJava, SML, Scala, or WebAssembly.

A picture is worth a thousand words

Anonymous
04 / Case studies

The notation at work.

Captures from MNL, B-MJ, B-Lambda, BFJ, ViSML and GraphLambda: evaluation strategies, compiler pipelines, type derivations, visual notation and source-anchored execution.

05 / Publications

Written up, and being written.

Published

PAINT

2025

The MNL: A Block-Based Functional Programming Language with Reactive Blocks

Read on ACM DL
In Progress

Ongoing

work in progress
  • Evaluation strategies for block-based languages.
  • Preserving the structure of a textual grammar when it becomes a block language.
  • Live types: principal typing suggestions for incrementally built programs.
  • An abstract machine for visual programming languages.
  • Derived, Not Stipulated: Type-Directed Edit Propagation from a Machine-Validated Signature Table
Future work

Future work

  • Live Effects: Liveness Through Holes Under Algebraic Handlers
  • One Demand, Two Directions: Type-Directed Editing and Type-Error Explanation from a Single Projection
  • Mirror-C: Proving a Block-Based Visualisation Faithful to a C Abstract Machine
  • Relational Live Types: Principal Projections for Correlated Sockets in Incomplete Programs