From statute to digital execution

RegelRecht explores whether legislation can be written as executable code, so that different organisations apply the same law the same way and citizens can follow how a decision is reached.

Running laws without programming

Executing legislation comes with several challenges: differing interpretations, opaque systems, and complex programming work that often sits far from the original law. RegelRecht explores whether machine-executable legislation can offer an answer: laws written directly as executable code, without programmers in between.

From analogue law to code

Can we transform traditional legislation into machine-executable specifications? We are investigating whether this can narrow the gap between legislator and execution.

Shared, verifiable execution

What if the way a law is executed were published in machine-executable form alongside the legal text itself? Different parties, from implementing organisations to citizens, could then independently verify and run that execution, and differences in interpretation would become visible instead of being hidden inside code.

Full transparency

How do we make government decisions more transparent? We are experimenting with ways for citizens to see which rules apply and how decisions are reached.

From statute text to digital execution

Drag the divider to see what sits between the Dutch Healthcare Allowance Act and an amount worked out. At the bottom the engine runs the scenario for real.

Statute → Machine-readable

What the law says

Article 3, first paragraph of the Wet op de zorgtoeslag: too much capital means no allowance. The text anyone can look up.

definitions: vermogensgrens_alleenstaand: value: 14189600 type: amount type_spec: unit: eurocent vermogensgrens_aanvrager_met_toeslagpartner: value: 17942900 type: amount type_spec: unit: eurocent execution: produces: legal_character: TOETS decision_type: GOEDKEURING parameters: - name: bsn type: string required: true input: - name: vermogen type: amount source: regulation: wet_inkomstenbelasting_2001 output: rendementsgrondslag parameters: bsn: $bsn type_spec: unit: eurocent - name: heeft_toeslagpartner type: boolean source: regulation: algemene_wet_inkomensafhankelijke_regelingen output: heeft_toeslagpartner parameters: bsn: $bsn output: - name: vermogen_onder_grens type: boolean actions: - output: vermogen_onder_grens value: operation: LESS_THAN_OR_EQUAL subject: $vermogen value: operation: IF cases: - when: operation: EQUALS subject: $heeft_toeslagpartner value: true then: $vermogensgrens_aanvrager_met_toeslagpartner default: $vermogensgrens_alleenstaand

In afwijking van artikel 7, derde lid, van de Algemene wet inkomensafhankelijke regelingen, bestaat geen aanspraak op een zorgtoeslag indien de rendementsgrondslag, bedoeld in artikel 5.3 van de Wet inkomstenbelasting 2001, van de verzekerde aan het begin van het berekeningsjaar meer bedraagt dan € 141.896 of, indien de verzekerde het gehele berekeningsjaar dezelfde partner heeft, de gezamenlijke rendementsgrondslag, bedoeld in artikel 5.3, van de Wet inkomstenbelasting 2001, van de verzekerde en zijn partner aan het begin van het berekeningsjaar meer bedraagt dan € 179.429. Bij de bepaling van de rendementsgrondslag, bedoeld in de vorige zin, wordt geen rekening gehouden met de vrijstelling, bedoeld in artikel 5.13 van de Wet inkomstenbelasting 2001.

Source: wetten.overheid.nl

StatuteMachine-readable

Memorandum → Scenario

Why it reads that way

The legislature works the allowance out itself in the parliamentary papers. That table is an executable scenario here: the same formula, checked to the euro. If it breaks, either the law moved or the execution no longer matches it.

Scenario: Inkomen boven het drempelinkomen bouwt de zorgtoeslag af Given the following "personal_data" data with key "bsn": | bsn | geboortedatum | verblijfsadres | land_verblijf | | 999993653 | 1990-01-01 | Amsterdam | NEDERLAND | Given the following "relationship_data" data with key "bsn": | bsn | partnerschap_type | partner_bsn | | 999993653 | GEEN | null | Given the following "insurance" data with key "bsn": | bsn | polis_status | verdragsinschrijving | | 999993653 | ACTIEF | false | Given the following "box1" data with key "bsn": | bsn | loon_uit_dienstbetrekking | uitkeringen_en_pensioenen | winst_uit_onderneming | resultaat_overige_werkzaamheden | eigen_woning | buitenlands_inkomen | | 999993653 | 3000000 | 0 | 0 | 0 | 0 | 0 | Given the following "box2" data with key "bsn": | bsn | reguliere_voordelen | vervreemdingsvoordelen | | 999993653 | 0 | 0 | Given the following "box3" data with key "bsn": | bsn | spaargeld | beleggingen | onroerend_goed | schulden | | 999993653 | 0 | 0 | 0 | 0 | Given the following "detenties" data with key "bsn": | bsn | detentiestatus | inrichting_type | zorgtype | juridische_grondslag | | 999993653 | null | null | null | null | Given parameter "bsn" is "999993653" When I evaluate "heeft_recht_op_zorgtoeslag" of "wet_op_de_zorgtoeslag" Then the execution succeeds Then output "heeft_recht_op_zorgtoeslag" is true Then output "hoogte_zorgtoeslag" equals 133084

Verslag houdende een lijst van vragen en antwoorden bij de VWS-begroting 2022, vraag 374: "Kunt u een berekening naar de Kamer sturen hoe hoog de zorgtoeslag voor de verschillende inkomensgroepen wordt in 2022?" Het antwoord geeft een tabel met acht inkomens, voor een- en meerpersoonshuishoudens. Bij een inkomen van 15.000, 20.000 en 22.356 euro staat telkens 1.336 euro voor een eenpersoonshuishouden; daarboven loopt het bedrag af naar 976 (25.000), 296 (30.000) en nul vanaf 35.000.

Kamerstukken II 2021/22, 35 925 XVI, nr. 14

ScenarioMemorandum

Execution

The engine runs

That very scenario, executed against the machine-executable law above. What you see happening below is happening now: the engine runs in this browser, on your machine.

Run

    Fetching the engine and the laws; the scenario runs here, in your browser.

    Allowance per year

    Applying laws currently raises several challenges for the rule of law

    We are investigating whether new technical approaches can contribute to solutions for these structural questions.

    The problem

    Differing interpretations

    The same law is interpreted and applied differently by different government organisations, leading to inconsistencies and injustice.

    Possible direction

    Unambiguous application

    Could machine-executable laws reduce interpretation problems? We are investigating whether this can lead to more consistent rule application.

    The problem

    Opaque decisions

    Citizens receive decisions with no explanation of how they were reached. Government as a black box.

    Possible direction

    Full traceability

    Can we make every decision traceable back to the exact rule that was applied? We are exploring options for more transparency in government decisions.

    The problem

    Unworkable laws

    Laws are often written without fully testing whether they are workable in practice. This can cause implementation problems through inconsistencies, ambiguities or practical constraints.

    Possible direction

    Testing workability

    Would machine-executable legislation make it possible to test laws? We are investigating whether inconsistencies and conflicts can be detected early.

    The transition from analog law to a digital legal system

    How might that unfold? We explore 7 possible steps and what each could make possible:

    Analogue to digital

    Can existing laws be systematically converted from analogue text into machine-executable specifications? A first step to explore a digital foundation.

    Digital legal system

    Could new laws be written machine-executable from the start? We explore what that could look like and how we can support it.

    Standardised ecosystem

    A national infrastructure where government systems use the same legal definitions. A shared, published baseline that every party works from and can independently verify.

    Harmonising legislation

    It becomes possible to work systematically on harmonising existing legislation. Conflicts and inconsistencies between existing rule sets can be detected automatically, making harmonisation a deliberate choice.

    Workability assessment

    New laws can be tested before they take effect. The effect of new legislation on the consistency of the legal system can be analysed during the legislative process.

    Central publication

    Machine-executable legislation is published centrally for everyone. Execution engines are made available too, so all parties can run the same laws in an identical way.

    Transparent application

    Citizens and businesses can inspect and verify exactly how rules work. Full transparency into rule application.

    Ecosystem

    Rule format

    YAML + JSON Schema

    Laws as YAML files, with the legal text and the machine-executable rules side by side. A versioned JSON Schema guards the structure. RFC-001

    BDD scenarios

    Gherkin + cucumber

    Expected outcomes are captured as readable scenarios. Legal experts and programmers read the same tests, and every change to the rules is validated immediately. Where possible we draw those scenarios straight from the explanatory memorandum.

    Execution engine

    Rust + WebAssembly

    A deterministic execution engine that runs the YAML rules. Written in Rust and compiled to WebAssembly so the same rules give the same result in the browser and on the server. Documentation

    Analogue-law converter

    AI-assisted

    An LLM-based tool that could turn existing analogue law into machine-executable rules. We are exploring what automatic transformation could look like.

    Editor

    Work in progress

    A working environment for legal experts to make laws machine-executable. We are still discovering what this editor should look like. Documentation

    Law graph

    Relationship analysis

    A visualisation of the relationships between different laws, that could show how changes to one law would ripple through the wider legal landscape.

    Corpus

    Git-based

    The library of machine-executable rules. Git handles the version history; a registry ties different sources into a single whole. Documentation

    Simulation environment

    What-if analysis

    An environment where the consequences of new legislation could be modelled before it takes effect, to surface societal impact and unintended effects. Live demo

    Publication platform

    API + web

    A central place for publication and distribution of machine-executable rules, with API access for government systems and private parties.

    A few directions for practice

    What could the RegelRecht ecosystem make possible? A handful of directions for transparent rule application, legislative testing, and the working environment of the legal experts themselves.

    Screenshot of a personal rules dashboard: a list of benefits and allowances where each rule shows its origin in the law.

    Personal rules dashboard

    What if citizens could see all their benefits, allowances and obligations in one place? Every rule could then be traceable back to the machine-executable legislation, with full transparency about how decisions are reached.

    • Real-time rule application: could it make immediate feedback possible?
    • Full traceability: can a path be drawn from law to personal situation?
    • Proactive communication: can citizens be informed automatically when rules change?

    See it in the demo

    Screenshot of a simulation environment that computes the effect of a legislative change across different example situations.

    Legislative simulation & testing

    What if policy makers could test the consequences of new legislation in a simulation environment before it is introduced? Could this prevent unintended effects and improve the quality of legislation?

    • Impact analysis: could we predict the consequences of new regulation?
    • Harmonisation check: can we detect conflicts with existing legislation?
    • Scenario testing: is it possible to test different policy options?
    • Quality control: can inconsistencies be detected before implementation?

    See it in the demo

    Screenshot of the RegelRecht editor: the text of the Health-Care Allowance Act on the left, machine-readable definitions and outputs in the middle, and scenarios with expected outcomes on the right. A note popup is open on a selected term.

    Editor with notes and scenarios

    What if legal experts, policy makers and programmers could work on legislation in the same environment? Notes on terms, machine-readable definitions and runnable scenarios, all alongside the original legal text.

    • Term-level annotation: can lawyers add explanations directly to specific terms?
    • Live scenarios: do we see immediately whether the rules still hold after a change?
    • Multiple laws side by side: can we surface cross-references between laws?

    RegelRecht contributes to projects from the 2025 Innovation Budget

    Fewer citizens in trouble through machine-readable legislation

    In collaboration with VNG

    How do we prevent the accumulation of laws and regulations from making laws unworkable? This project explores developing an analysis tool to test legislative proposals for workability in conjunction with other laws.

    A modern calculation core as a building block for government

    In collaboration with Dienst Toeslagen

    Can we develop a general calculation core for government? This project explores how such a system could help execute complex schemes for citizens and businesses, for example when calculating allowances.

    Research

    This exploration raises questions that reach beyond technology: what it means for the balance between the branches of government when law execution becomes public and checkable, and what legal status an executable specification has. We write that up for an academic audience, so that legal and public-administration scholars can test and sharpen it.

    Rules as Executed: Publishing Machine-Executable Law to Rebalance the Powers

    Position paper • Eelco Hotting & Anne Schuth • 31 August 2026

    The paper argues that government should publish its law execution as machine-executable specifications, with every decision recording the version that produced it. The recipient of a decision can then recompute it, and Parliament can analyze the rule itself.

    Important reports, studies, and sources on the need for machine-executable legislation

    Factsheet on the digital execution of legislation

    Prof. Corien Prins (WRR) & Prof. Johan Wolswinkel (Tilburg University) • 23 January 2025

    This WRR factsheet identifies five points of attention and review questions for parliamentary oversight of the digital execution of legislation. The RegelRecht project falls within the scope of this factsheet and can be assessed against the proposed criteria for transparency, traceability and democratic control.

    Factsheet on rule-of-law risks of the digital execution of laws

    Dr. Mariette Lokin (OU/VU) & Prof. Reijer Passchier (OU/Leiden University) • 29 November 2024

    This factsheet for the House of Representatives’ Standing Committee on Digital Affairs names six rule-of-law risks of digital law execution, including opacity and translation problems between legal text and code, and argues for traceability of algorithms back to their legal source.

    Information management, the stagecoach with an auxiliary motor

    Arre Zuurmond (Government Commissioner) • 1 May 2023

    Zuurmond observes that current information management supports a bureaucratic, reactive government too strongly based on distrust of citizens. He argues for a responsive government with better information provision.

    Algorithms tested

    Netherlands Court of Audit • 18 May 2022

    The Court of Audit tested 9 algorithms at various government organisations and found that 6 of them carried risks around performance management, bias, data leaks or unauthorised access. The report stresses the need for continuous monitoring.

    Attention to algorithms

    Netherlands Court of Audit • 26 January 2021

    This first systematic study of algorithm use by the Dutch government found that algorithms focus mainly on government needs, with limited attention to ethical aspects and citizen insight.

    Recommendations on the legislative process and quality

    Council of State (Advisory Division) • 19 April 2021

    The Council of State stresses the importance of implementation assessments and collaboration between policy makers, legislative lawyers and implementing organisations in multidisciplinary teams, and argues for better testing of workability and citizens’ ability to act.

    Moderate growth: State Commission on Demographic Developments 2050

    State Commission chaired by Richard van Zwol • 15 January 2024

    The State Commission observes that demographic developments put pressure on the accessibility of government services such as education, healthcare and housing.

    Make it happen! The digital government

    Study Group on the Information Society and Government (chaired by Richard van Zwol) • 18 April 2017

    The study group concludes that digitising government requires a radical change of mindset and that digital service delivery belongs at the core of the primary process.

    Work on Implementation, Phase 2: Courses of action

    Interdepartmental (BZK, Finance, OCW, SZW) • 3 July 2020

    This report analyses problems at implementing organisations such as the Tax Administration, DUO and UWV: continuity risks, limited agility when policy changes, and missing options for tailored solutions.

    Open and in order: generic action plan for information management

    Ministry of the Interior • 6 April 2021

    This action plan was drawn up in response to the 'Unprecedented injustice' report and focuses on structurally improving information management across central government.

    Where this is going

    The work is split across five phases, from setting down the basics to embedding them in everyday practice. Each work package states what needs to happen, who is working on it and which questions are still open. The early phases are worked out; the later ones are named but not yet broken down. The roadmap itself is in Dutch.

    Fase I

    Wat · Fundering en definitie

    26 work packages

    Setting down what machine-readable legislation is, and what it has to be able to do.

    Fase II

    Wat · Verdieping en onderzoek

    16 work packages

    Working out where the approach holds and where it breaks, with research per area of law.

    Fase III

    Hoe · Operationalisering en tooling

    7 work packages

    Building the tools that let lawyers and implementing bodies do the work themselves.

    Fase IV

    Waar · Institutionele verankering

    Not yet broken down

    Establishing where this belongs: which organisations, under which agreements.

    Fase V

    Garantie · Maturiteit en systeemwaarborging

    Not yet broken down

    Making sure it keeps holding up as laws change and people move on.

    Frequently asked questions

    What happens to open norms?

    Laws deliberately leave room for interpretation: terms that are filled in "by ministerial regulation", or concepts that leave a judgement to the implementing body. In ordinary automation that room quietly disappears into code: the choice the programmer makes effectively becomes law, with no publication or scrutiny. RegelRecht turns that choice into something explicit instead: the higher law marks an open norm, the lower regulation fills it in, and lawyers can record whether a concept is fully, partly or not yet filled in. That makes visible where the statute ends and interpretation begins. Genuinely human judgements inside a decision process, such as a hardship clause or a case-by-case assessment by an official, stay human work; we are not trying to automate those away.

    What could a digital legal system mean?

    Legal rules are written as executable code that computers can run and apply directly, without human interpretation or programmers in between. Is that achievable? And how does it relate to traditional analogue law?

    How could this relate to existing systems?

    Can RegelRecht validate existing implementations and serve as a reference for new systems? Existing systems are not directly replaced, but verification and modernisation come within reach.

    Could RegelRecht be legally binding?

    RegelRecht is a technical aid. Legal validity remains with the original legislation. The open question is whether it can help with consistent interpretation and application.

    Does this mean one central interpretation?

    No. RegelRecht explores whether the way a law is executed can be published, not whether one party decides what is true. The competent authority publishes its reading as the authoritative interpretation, but other organisations, lawyers and citizens can publish their reading alongside it. Execution is not tied to a single engine either: multiple independent implementations must produce the same outcome on the same rules and data. What becomes central is publication and verifiability, not interpretation itself.

    Do I have to run your Rust engine in my own landscape?

    No. RegelRecht fixes the rule format and the intended outcomes, not the implementation. The Rust engine is the reference implementation: it shows what the rules are meant to do and serves as the benchmark other implementations can measure themselves against. An engine can also be implemented differently, in another language or architecture, so that it fits your landscape. What matters is that every implementation produces the same outcome on the same rules and data as the reference.

    Why a dedicated rule format?

    The format is YAML, with legal text and machine-executable rules side by side in a single file. A versioned JSON Schema guards the structure, and BDD scenarios capture the intended outcomes. Legal experts can read along, developers can contribute, and different government systems can use the same rules. Read RFC-011

    How does this contribute to transparency?

    By making rules explicit in code, citizens and organisations can see exactly how decisions are reached, instead of relying on opaque systems.

    Help shape this exploration

    This exploration of machine-executable legislation raises many questions. How do you see the future of digital government? What are your concerns and expectations around these developments? Your input helps us shape this exploration further.

    RegelRecht

    An exploration by Bureau Architectuur of the Dutch Ministry of Economic Affairs and Climate Policy into the possibilities of transparent, executable legislation.

    Links

    GitHub repository
    How it works
    Stay informed
    Roadmap (Dutch)
    Documentation
    Research

    Contact

    regelrecht@minbzk.nl

    Part of

    Bureau Architectuur
    Ministry of Economic Affairs and Climate Policy