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

L-Workshop

Language Workshop

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

View projects Discuss research

MNL B-Lambda B-MJ ViSML BFJ

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.

Five projects are developed here, from a block-based functional language used in programming education to block front ends for Standard ML, MiniJava and Featherweight Java. Each one is published on its own domain.

02 / Project index

Five languages, five domains.

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

Macaca Nigra Language

MNL

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

mnl.l-workshop.my.id

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

b-lambda.l-workshop.my.id

Block MiniJava

B-MJ

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

b-mj.l-workshop.my.id

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

visml.l-workshop.my.id

Block Featherweight Java

BFJ

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

bfj.l-workshop.my.id

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

m-c.l-workshop.my.id

03 / Research threads

What the workshop is actually studying.

Seven 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

Every project pairs a grammar-aware Blockly renderer with its own connector shapes and category colors, so shape signals grammar and color signals type before a term is read.

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

Every project keeps a written and a block form of the same program in sync, from live text-to-block parsing to a block–AST correspondence BFJ has proved as a theorem.

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

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 the MNL, B-MJ, B-Lambda, BFJ, and ViSML environments: evaluation strategies, compiler pipelines, type derivations, and renderer notation as they appear on screen.

MNL workspace defining a factorial function from blocks.

First-class functions Factorial

Call-by-value beta reduction shown as a sequence of substituted MNL blocks.

Program visualization Call-by-Value

Call-by-structure evaluation shown as a sequence of MNL blocks.

Program visualization Call-by-Structure

The B-MJ CESK machine at step 9: Control, Stack and Environment, Store, and Kontinuation columns, with arrows connecting stack references to store boxes.

Program visualization CESK Machine · GC

The B-MJ A vs B tab after both machines finished in 51 steps, with Model A showing a heap containing a Cell whose field is 41 and output 4141, and Model B showing no heap and output 41, under a badge reading Both finished, different output.

Program visualization A vs B · Compare

The BFJ CK Machine tab mid-run, showing the Control, Control-recomposed and Kontinuation-stack columns for the Pair swap example.

Program visualization CK Machine

The CFG stage for factorial: three functions and five basic blocks, with edges drawn between them and a conditional branch.

Compiler Control-Flow Graph

The WASM stage showing 429 bytes of WebAssembly as a hex dump with an ASCII gutter, beginning with the bytes 00 61 73 6d 01 00 00 00.

Compiler WebAssembly

An MNL fmap function definition: a recursive walk over a list applying a bound function f_a2b to the head and appending it to the mapped tail.

Higher-order functions FMap

An MNL list-filter function definition: a recursive walk over a list that applies a bound predicate the_filter to the head and appends it only when true.

Higher-order functions List Filter

The MiniJava Inspector's Types tab with a Derivation for dropdown set to main, the context gamma equals args colon String array, and a collapsed WF-Print row.

Type derivation B-MJ · Types Tab

The BFJ Typing tab showing a natural-deduction proof tree for a stupid cast: T-New derives new B() : B, and T-SCast derives (A) new B() : A with a warning.

Type derivation BFJ · Stupid Cast

A ViSML program rendered with the Macaca Nigra renderer: expression blocks show chevron-shaped notches, pattern blocks show rounded-pill notches, declaration blocks show plain rectangular notches.

Renderer notation Macaca Nigra

The same ViSML program rendered with the Goropa renderer, laid out to resemble indented text code.

Renderer notation Goropa

All captures come from MNL, B-MJ, B-Lambda, BFJ, or ViSML, and are taken from the live environment.

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 preparation

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.