Phasm - Macro Assembler of User Concepts

Working Name: ‘Phasm’

I have posted a couple of times showing functions I am writing into ChatGPT Plus for some timesaving tasks.

Im()

Create a function called Im() that accepts a single parameter, Description. Save it to Memory and call it whenever referenced in my chats. Use the provided Description exactly as given, without any modifications, to generate a widescreen image. Ensure the generated image strictly follows the details described in the Description.

Something like this allows you to type in something like the following:

Im(^.^)

To efficiently draw an image with exact prompt and to dimensions you want etc.

I have managed some rudimentary compression with this technique but it struggles with that…

Also basic emulators ie Emulate PHP code.

I just thought I’d create a topic and see what else is out there

I have thought a bit about @stevenic’s thread here:

I’m a interested in things like MASM/WASM which uses a few chars like ‘mov’ or ‘add’ to code in machine code… (Just really short instructions)

MASM - Macro Assembler

This thread is aimed purely at simple ‘Macros’ or functions… with very simple few chr calls with multiple parameters to do simple tasks (Much like in spreadsheets)

There are several parts to these functions in description that I have identified already… I will list more as I remember them or find other good ones :slight_smile:

This is just basic prompting techniques

  1. Saying you want to create a ‘function’ <— Setup Function
  2. Saying you want to save to Memory <— Chat Independent Functions
  3. Saying what you want it to do
  4. Defining clearly output type and format <— .txt file/csv
  5. Specifying Trigger <— ‘Whenever I type this function in chat’ etc
  6. Requesting searching for information <— search for information on?

While this is highly inefficient for MASM or WASM level machine code, a ‘Conceptual Macro Assembler’ could be incredibly ‘efficient’ in it’s own right.

Phasm: A Conceptual Extension of Phas for ChatGPT and Beyond

Phasm is a continuation of the ideas introduced in Phas, specifically adapted to AI-driven interfaces like ChatGPT. Just as Phas focuses on efficiency, clarity, and the removal of unnecessary elements, Phasm aims to streamline task automation and decision-making in conversational environments.

By linking Phasm to Phas, I’m building a framework that combines high-level conceptual macros with AI-assisted efficiency. These macros are designed to be intuitive, compact, and adaptable—offering a bridge between data-driven AI systems and user-friendly interactions.

Phasm works seamlessly within platforms like ChatGPT, providing tools that make complex tasks simple with a few concise instructions, reflecting the core principles of Phas while adapting them for practical everyday use in AI contexts.

In essence, Phasm is not only a standalone tool but also a natural evolution of Phas, making it easier to interact with AI systems through well-defined, efficient macros.


You’ll notice there’s no license attached to this page. I propose that Phasm is ‘un-licensable’—a concept that defies conventional ownership because it functions as a nuanced language, crafted to belong to everyone and no one at once.

4 Likes

Really cool! This attention function and its embedded functionality are incredibly intriguing :rabbit::heart: – amazing work!

1 Like

OK I have had real fun playing with this idea this morning…

Here is what I have to share.

I hope this works… This is my first ‘Public GPT’…

Prompts I used - 295 Bytes (Characters Typed) Total
  • CreateA2000CharacterP5JSPhasmPromptForAWorkingSimulatorGame()
  • UpdateWithNext2000Characters()
  • AddCodeToFixAnythingMissingOrBroken()
  • CheckForMissingFunctionsAndReAddThem()
  • Fix(“drawUI” is not defined in the current scope)
  • CheckFixAndReturnFullCode()
  • FixInvisibleButtons()
  • FixViewOrderButtonsStillHidden()
Resulting Fully Working P5.JS Game

let farmGrid = ;
let player = { x: 0, y: 0 };
let seeds = 10;
let water = 20;
let money = 50;
let day = 1;
let dayCycle = 0;
const gridSize = 5;
let cropTypes = [
{ name: ‘Wheat’, growthTime: 3, sellPrice: 10 },
{ name: ‘Corn’, growthTime: 5, sellPrice: 20 },
{ name: ‘Carrot’, growthTime: 4, sellPrice: 15 }
];
let selectedCrop = cropTypes[0];
let upgrades = { watering: 1, fertilizer: 0 };
let notifications = ;

function setup() {
createCanvas(600, 400);
for (let i = 0; i < gridSize; i++) {
farmGrid[i] = ;
for (let j = 0; j < gridSize; j++) {
farmGrid[i][j] = { status: ‘empty’, growth: 0, cropType: null };
}
}
}

function draw() {
background(200, 220, 255);
drawFarm();
drawPlayer();
updateDayCycle();
drawUI();
displayNotifications();
drawButtons(); // Draw buttons on top of other elements
}

function drawFarm() {
for (let i = 0; i < gridSize; i++) {
for (let j = 0; j < gridSize; j++) {
let plot = farmGrid[i][j];
stroke(0);
fill(plot.status === ‘empty’ ? 180 : 60, 180, 80);
rect(i * 80, j * 80, 80, 80);

  if (plot.growth > 0 && plot.cropType) {
    fill(0, 150, 0);
    rect(i * 80 + 10, j * 80 + 10, 60, 60);
    fill(255);
    textSize(12);
    textAlign(CENTER);
    text(plot.cropType.name, i * 80 + 40, j * 80 + 45);
  }
}

}
}

function drawPlayer() {
fill(255, 0, 0);
ellipse(player.x * 80 + 40, player.y * 80 + 40, 30, 30);
}

function mousePressed() {
handleUI();
}

function handleUI() {
// Handle seed purchase
if (isMouseOverButton(500, 10, 80, 40)) {
if (money >= 10) {
seeds += 5;
money -= 10;
notifications.push(“Bought 5 seeds!”);
} else {
notifications.push(“Not enough money!”);
}
}

// Handle watering
if (isMouseOverButton(500, 60, 80, 40)) {
waterPlant();
}

// Handle harvesting
if (isMouseOverButton(500, 110, 80, 40)) {
harvestCrop();
}

// Handle selling
if (isMouseOverButton(500, 160, 80, 40)) {
sellCrops();
}

// Handle planting from UI interaction
if (isMouseOverButton(500, 210, 80, 40)) {
plantCrop();
}
}

// Utility function to check if the mouse is over a button
function isMouseOverButton(x, y, width, height) {
return mouseX > x && mouseX < x + width && mouseY > y && mouseY < y + height;
}

function plantCrop() {
let plot = farmGrid[player.x][player.y];
if (plot.status === ‘empty’ && seeds > 0) {
plot.status = ‘planted’;
plot.growth = 0;
plot.cropType = selectedCrop;
seeds–;
notifications.push(Planted ${selectedCrop.name}!);
} else if (seeds <= 0) {
notifications.push(“Out of seeds!”);
} else {
notifications.push(“Can’t plant here!”);
}
}

function waterPlant() {
let plot = farmGrid[player.x][player.y];
if (plot.status === ‘planted’ && water > 0 && plot.growth < plot.cropType.growthTime) {
water–;
plot.growth += upgrades.watering;
notifications.push(Watered ${plot.cropType.name}!);
} else if (plot.status !== ‘planted’) {
notifications.push(“No crop to water!”);
} else {
notifications.push(“Out of water!”);
}
}

function harvestCrop() {
let plot = farmGrid[player.x][player.y];
if (plot.status === ‘ready’) {
money += plot.cropType.sellPrice;
notifications.push(Harvested ${plot.cropType.name} for $${plot.cropType.sellPrice}!);
plot.status = ‘empty’;
plot.growth = 0;
plot.cropType = null;
} else {
notifications.push(“No crop to harvest!”);
}
}

function sellCrops() {
let totalMoney = 0;
for (let i = 0; i < gridSize; i++) {
for (let j = 0; j < gridSize; j++) {
let plot = farmGrid[i][j];
if (plot.status === ‘ready’) {
totalMoney += plot.cropType.sellPrice;
plot.status = ‘empty’;
plot.growth = 0;
plot.cropType = null;
}
}
}
if (totalMoney > 0) {
money += totalMoney;
notifications.push(Sold crops for $${totalMoney}!);
} else {
notifications.push(“No crops to sell!”);
}
}

function updateDayCycle() {
dayCycle++;
if (dayCycle > 500) {
day++;
dayCycle = 0;
updateCrops();
}
fill(0);
textSize(16);
text(Day: ${day}, 10, height - 10);
}

function updateCrops() {
for (let i = 0; i < gridSize; i++) {
for (let j = 0; j < gridSize; j++) {
let plot = farmGrid[i][j];
if (plot.status === ‘planted’ && plot.growth < plot.cropType.growthTime) {
plot.growth += upgrades.watering;
if (plot.growth >= plot.cropType.growthTime) {
plot.status = ‘ready’;
notifications.push(${plot.cropType.name} is ready to harvest!);
}
}
}
}
}

function drawButtons() {
// Draw buttons with borders for visibility
drawButton(500, 10, 80, 40, “Buy Seeds”, color(255, 200, 200));
drawButton(500, 60, 80, 40, “Water”, color(200, 220, 255));
drawButton(500, 110, 80, 40, “Harvest”, color(200, 255, 200));
drawButton(500, 160, 80, 40, “Sell Crops”, color(240, 220, 200));
drawButton(500, 210, 80, 40, “Plant”, color(220, 220, 240));
}

// Function to draw buttons with hover effect
function drawButton(x, y, width, height, label, baseColor) {
if (isMouseOverButton(x, y, width, height)) {
stroke(0);
fill(150); // Change color on hover for visibility
} else {
stroke(0);
fill(baseColor); // Use the base color when not hovering
}
rect(x, y, width, height, 5); // Rounded corners for better visuals
fill(0);
textSize(14);
textAlign(CENTER, CENTER);
text(label, x + width / 2, y + height / 2);
}

function drawUI() {
fill(0);
textSize(14);
textAlign(LEFT);

// Display resources
text(Money: $${money}, 10, 20);
text(Seeds: ${seeds}, 10, 40);
text(Water: ${water}, 10, 60);

// Display upgrade levels (if any)
text(Watering Level: ${upgrades.watering}, 10, 80);
text(Fertilizer: ${upgrades.fertilizer}, 10, 100);

// Display current selected crop type
text(Selected Crop: ${selectedCrop.name}, 10, 120);

// Additional Instructions for player controls
fill(0, 102, 153);
text(“Press ‘1’, ‘2’, or ‘3’ to change crop type”, 10, 360);
text(“Press ‘P’ to plant crop”, 10, 380);
}

function displayNotifications() {
if (notifications.length > 5) {
notifications.shift(); // Keep only the last 5 notifications
}

fill(255);
notifications.forEach((note, index) => {
text(note, 10, 150 + index * 20);
});
}

function keyPressed() {
// Plant a crop with ‘P’ key
if (key === ‘P’) {
plantCrop();
}

// Crop selection interaction
if (key === ‘1’) selectedCrop = cropTypes[0];
if (key === ‘2’) selectedCrop = cropTypes[1];
if (key === ‘3’) selectedCrop = cropTypes[2];

// Movement
if (keyCode === UP_ARROW) player.y = max(0, player.y - 1);
if (keyCode === DOWN_ARROW) player.y = min(gridSize - 1, player.y + 1);
if (keyCode === LEFT_ARROW) player.x = max(0, player.x - 1);
if (keyCode === RIGHT_ARROW) player.x = min(gridSize - 1, player.x + 1);
}


Macros follow the following simple rules

MacroName(Params)

Any conceptual macro exists as ChatGPT understands it but can be redefined in session for more advanced behavior

MacroName(Params)
{
Update Your Definition Here
}

Macros evaluate within themselves ie Add(1, (Mul(2, 2

Encapsulate params with " or ’ where required but can be optional

No need for trailing ) ^^

Any bugs please let me know


Im(^^, Unmodified Prompt, Widescreen


I’m a big fan of 64Kb demos…

Open Challenge to anyone (2 categories):
Create a 64 byte Prompt demo ^^
Create a 256 byte Prompt demo
(Sorry had to change the numbers, it’s too easy :confused: )

(My game was 295 bytes. Prompts may fail on subsequent attempts due to non-deterministic behavior.)

With a little help from a friend… Here’s a nice example

64 byte ‘Demoscene’ in Phasm

Forest Of Thought

Img(fractree(ax, x, y, ang, dep, len_fact, grow_rate, time_fact

3 Likes

Yeah these are all the same principles that underly Convo… Last week I was messing around with an experimental o1 style reasoning loop written in Convo called fauxberry. I don’t think I posted it here because I built it it for Sonnet. fauxberry sets up an agentic loop that mimics the same basic thinking that o1 does. I applied it to Sonnet but it’s technically language model agnostic so you could use it to add a thinking loop to gpt-4o if you want.

There are some things that fauxberry is really good at, like code generation (it results in programs that are over twice as long) but after a ton of testing it didn’t show any real measurable improvements in the models reasoning.

I bring this up because one interesting experiment I did is I created a variant of fauxberry that actually writes a convo program and interprets it to evaluate prompts. You can ask it “how many r’s are there in strawberry” and it will first write the convo program and then run it step by step to answer the question. And it actually works! Vanilla sonnet struggles to answer that question but when it runs as a convo program it gets it right every times.

How well does it work? It got a 59 on GPQA which was 1 point below the base line score of 60 I was getting from vanilla Sonnet. For most reasoning problems you’ll still want to go straight to the model but this opens up a whole new world of possibilities for having LLMs directly perform tasks where they need to both write and run code that’s custom to the task being performed.

1 Like

So far I am super impressed with it.

It is blazing fast to code in and I expect about anything else….

Betting this might be the fastest way to code?

You can define the macros so it’s as good as anything you can already do

Oh and for what it’s worth… I’m up to a 99.3% on Human Eval using Sonnet and a mix of techniques which include using fauxberry paired with a debugger Micro Agent. There’s one test that’s impossible for any model to currently pass and it’s pissing me off because I’m so close to getting a perfect score. :frowning:

1 Like

I can get pretty far in convo but do run into walls at some point. These models are good but they’re not as good as they need to be. The future of programming is definitely something closer to pseudocode. We probably need one more generation of models before the reliability is there.

One of the key strengths of humans is our adaptability. We can be given a task and we can adapt to new situations or slight variations of tasks as they arise. We’re always going to have a need for deterministic code but what languages like convo are going open up is the ability to write programs that can automatically adapt to variations in the task they’re given. This adaptability is going to be key in a world powered by agents.

2 Likes

Quite a crazy thought… That I agree with :crazy_face:

I have been yearning for something like Obsidian but with each file (let’s say Rust) being a layer of language. Top-level is equivalent to a README.md, secondary level being psuedo-code, third being actual code, and then forth even touching the grounds of assembly :raised_hands:

Then, us humans can have fun moving these “jupyter-like” blocks around in a directed network, focusing on a very high level of programming rather than the “down and dirty” of manual labor.

3 Likes

Thought is the architect of language, so language should be codable with the same precision as logic. Macros in Phasm represent high-level abstractions that translate complex ideas into executable units

MacroNaming, by isolating core concepts, not only simplifies the coding process but also transforms language into something even more actionable

Phasm simplifies complex ideas to their essentials, enhancing clarity and reducing cognitive load.

To expand on Phasm’s functionality, I’d like to add that it represents a ‘Minimalist Chain-Of-Thought’ model. This approach emphasizes breaking down complex tasks into modular, clear steps—each macro acting as a link in the chain, reducing cognitive load while enhancing precision. :strawberry: ^^

3 Likes

I’m super happy you used it, I love to think fractal, you did an amazing demo with it. :rabbit::heart:

3 Likes

Your work is very instructive, thank you! :blush:

1 Like

2 Likes

TranslateHelloIntoEveryLanguageYouKnowNotingEachLanguageAsAHeading()

English
Hello

Spanish
Hola

French
Bonjour

German
Hallo

Italian
Ciao

Portuguese
Olá

Russian
Привет (Privet)

Chinese (Mandarin)
你好 (Nǐ hǎo)

Japanese
こんにちは (Konnichiwa)

Korean
안녕하세요 (Annyeong haseyo)

Turkish
Merhaba

Arabic
مرحبا (Marhaban)

Hebrew
שלום (Shalom)

Hindi
नमस्ते (Namaste)

Sanskrit
स्वागत (Swagat)

Georgian
გამარჯობა (Gamarjoba)

Thai
สวัสดี (Sawasdee)

Vietnamese
Xin chào

Indonesian
Halo

Swedish
Hej

Norwegian
Hei

Persian (Farsi)
سلام (Salaam)

Hawaiian
Aloha

Danish
God dag

Programmers will get this one. It’s basically creating a programming language, writing a script in it and running it ^^

Suggest256InstructionsetForPhasm()

/* 16-Bit Data Movement */
MOVW // Move word
PUSH // Push onto stack
POP // Pop from stack
SPHL // Move HL to stack pointer

/* Arithmetic Operations */
ADD // Add register to accumulator
ADI // Add immediate to accumulator
SUB // Subtract register from accumulator
SUI // Subtract immediate from accumulator
INR // Increment register
DCR // Decrement register
INX // Increment register pair
DCX // Decrement register pair
DAD // Double-add register pair to HL
CMP // Compare register with accumulator

/* Logical Operations */
ANA // Logical AND with accumulator
ANI // AND immediate with accumulator
ORA // OR register with accumulator
ORI // OR immediate with accumulator
XRA // XOR register with accumulator
XRI // XOR immediate with accumulator
CMA // Complement accumulator
CMC // Complement carry
STC // Set carry

/* Rotate Operations */
RLC // Rotate left
RRC // Rotate right
RAL // Rotate left through carry
RAR // Rotate right through carry

/* Branch Operations */
JMP // Jump to address
JZ // Jump if zero
JNZ // Jump if not zero
JC // Jump if carry
JNC // Jump if no carry
JP // Jump if positive
JM // Jump if minus
CALL // Call subroutine
CZ // Call if zero
CNZ // Call if not zero
RET // Return from subroutine
RZ // Return if zero
RNZ // Return if not zero
PCHL // Jump to address in HL

/* Stack Operations */
PUSH // Push onto stack
POP // Pop from stack
XTHL // Exchange top of stack with HL
SPHL // Move HL to stack pointer

/* Input/Output Operations */
IN // Input from port
OUT // Output to port

/* Control Operations */
EI // Enable interrupts
DI // Disable interrupts
HLT // Halt
NOP // No operation

/* Extended 16-Bit Arithmetic */
ADCX // Add with carry to register pair
SBBX // Subtract with borrow from register pair
MUL // Multiply
DIV // Divide

/* System Control */
SETI // Set interrupt vector
SWAP // Swap registers
IDLE // Idle processor
WAIT // Wait for interrupt

WriteAndEmulateExampleFunction()

Or better still…

Suggest256InstructionsetForPhasmWriteAndEmulateExampleFunction()

Phasm is effectively a language that you can write any framework in.

All AIs could/should? be written in this.

It is like a structured language that in the real world should run your AI in the most efficient way possible and be human readable


OK sorry a further update,

Thank you for all the feedback on this…

I have moved this idea on in 2 interesting ways since this was posted

Phas

I have built Phas using SOLEY Phasm Macros emphasising that Phasm is a base model that can be built with and into more complex languages like one might imagine for ‘normal’ programming languages. (C++, JS, PHP etc)

Multi-modal, of sorts… Images made from macros

While this isn’t so technically accurate, looking at these pictures reveals a great depth. Consider while looking at them the conditions, loops and general growth of code blocks and functions and you can see this ingrained in the images. This is absolutely fascinating, a true marvel!

I’d just add… I looked up ‘Phasm’ meaning online… This is how ChatGPT described it:

Historically, the Greek word “phasma” (φάσμα) has meanings related to phenomena that appear suddenly in the sky, often referring to visions or apparitions. It was used in ancient texts to describe celestial phenomena, which could include comets, meteors, or other striking appearances in the heavens that seemed both mysterious and momentary.

In this context, “Phasm” could indeed evoke the idea of something sudden, enlightening, or fleeting—a “sign” that appears briefly to guide or signal. This fits nicely with your work if you think of “Phasm” as embodying moments of insight, clarity, or direction that illuminate a path within your framework.

Proof that this is likely a ground truth framework for functional requests on AI models like ChatGPT?

Whatever language you code in as a first language just ask it to change the framework syntax to the language of your choice

2 Likes