Line, Language with Intuitive and Natural Expression
Italian syntax is charming but limits audience to Italian speakers specifically.
An experimental virtual processor that has an LLM instead of an ALU. It's starting to look like a virtual machine for software 2.0.
This repo turns agent loops into tiny, explicit instructions (LF, LI, APP, INF, INT, BGT, OUT) so you can compose reasoning as discrete micro-prompts instead of one huge monolith. The example VIBE_CONTROLLER shows concrete ops for cognition, safety checks and branching — a neat way to formalize ReAct-style loops. It’s a clever, researchy DSL with a Rust interpreter, but it’s early-stage and sits in a crowded space of agent frameworks (needs runtime benchmarks, integrations and real-world demos to move beyond an interesting experiment).
Prompt engineers, AI researchers, indie devs and hobbyists building agent architectures
I wanted to share something that I've been working on for the past couple of weeks. This was born from my desire to create my own toy fantasy console. One day, I had a thought:
Imagine if I had a console where the core driver/engine of it was an LLM? Or better yet, why not replace the ALU inside the CPU with an LLM?
What would the assembly language look like and what are the primitive data types (I can firmly blame Crafting Interpreters for this addiction)?
So I set out to answer my question by creating a simple interpreter which consumes a special kind of assembly code where each operation is transformed into small prompts (micro prompts?).
Think of a future where we would be writing code as follows:
``` ; PROGRAM: VIBE_CONTROLLER.aasm ; Objective: Adjust room environment based on subjective user vibe.
START: ; Initialise State LF X1, "room_sensors.json" ; Load current state: {temp: 18C, lights: 6000K, music: Off} LI X2, "Make it more warm." ; Load the user's vague complaint
; Load the user's desired vibe LI X3, "Goal: Warm, inviting, comfortable, relaxed."
; The Cognitive Operation APP X4, X2, X3 ; Apply the user's complaint and goal to generate a new state for the room.
; Predict the new state of X1 (Sensors) given X4 (Complaint + Goal). ; The LLU calculates: "Sterile" (Cold/White) -> Needs Warmer Temp + Warmer Light. INF X5, X1, X4 ; X5 now holds the generated JSON: {temp: 22C, lights: 2700K, music: "LoFi Jazz"}
; Safety Guardrail ; Ensure that the generated state (X5) is aligned with safety rules (X6). LI X6, "Constraint: Max Temp 23C. No Music if time > 11PM." INT X7, X5, X6 ; X7 stores 100 if safe, 0 if unsafe.
; Branching Logic LI X8, 0 BGT X7, X8, HANDLER ; If aligns with intention, jump to error handler ; Execute OUT X5 ; Send new config to IoT Hub EXIT
HANDLER: LI X8, "{error: 'Request conflicts with safety protocols.'}" OUT X8 ```What we have here is essentially an agent, but the assembly language for agents can be thought of as a middle ground between traditional programming languages and natural language prompts. It's more structured and modular than natural language prompts.
I would love to see what new, fun, and creative ways we can use this for.
Repo: https://github.com/HuyNguyenAu/assembly_language_for_agents
Italian syntax is charming but limits audience to Italian speakers specifically.
Clean browser-based 68K simulator with live register visualization for learning.
Treats model calls as first-class runtime constructs using $..$ blocks with declared-type enforcement, which makes it unusually ergonomic to intermix deterministic code and LLM-powered operations. The Polars-backed dataframe injection that emits structured JSON summaries instead of raw table dumps is a clever, practical touch for token efficiency; neat sandbox for language designers, but explicitly a hobby/toy project rather than something to deploy.
403 error on the landing page — can't verify the paper or any implementation exists.
Rails-native LLM agent DSL with built-in cost tracking and multi-tenant dashboard.
Pure Python interpreter with C FFI, but performance caps at Python speeds.