DEV Community: Hideaki

Creating a PHP, Go, and Python Quine Relay

Hideaki — Wed, 11 Feb 2026 14:42:35 +0000

I have created a Quine relay involving PHP, Go, and Python, and I’m here to explain how it works.
This is the code for QuineRelay.php:

<?=eval($_='print "package main;import\42fmt\42;func main(){fmt.Print(\140print(r\47\47\47<?=eval(\44_=\47$_\47);\47\47\47)\140)}";');

Yes, it probably looks like total nonsense. I will explain it step by step.
Now, you can see many things like \42. In PHP, inside double quotes, these are treated as octal ASCII codes and converted into characters.
For example, a double quote is ASCII code 34, which is 42 in octal.
Therefore, \42 will be a double quote.

I have created a conversion table below:

Octal	ASCII Code	Character
42	34	" (Double Quote)
47	39	' (Single Quote)
140	96	Backtick

(I couldn't put the actual backtick in the table without breaking the markdown 😅)

The advantage of using this octal notation is that these characters do not need to be escaped when they are included in Go or Python strings.
The difficult part of a Quine is how to handle characters like double quotes or single quotes that require escaping when they appear within a string, but by using octal notation, the need for escaping is eliminated.

Now, notice that the variable $_ is declared as an argument for the eval function at the beginning.
Let's look at the content of variable $_. Since $_ is enclosed in single quotes, the octal notation is treated literally as backslashes and numbers.

// inside $_
print "package main;import\42fmt\42;func main(){fmt.Print(\140print(r\47\47\47<?=eval(\44_=\47$_\47);\47\47\47)\140)}";

This code is then eval'ed. Since the string passed to print is enclosed in double quotes, the conversion from octal to ASCII occurs this time.
Also, $_ appears toward the end within the double quotes. In PHP, variable names inside double quotes are expanded with the value, so the second $_ will be expanded as the actual content of the variable.
The expansion of this $_ is the key trick to this Quine.
Running this PHP code outputs the following Go code:

package main;import"fmt";func main(){fmt.Print(`print(r'''<?=eval($_='print "package main;import\42fmt\42;func main(){fmt.Print(\140print(r\47\47\47<?=eval(\44_=\47$_\47);\47\47\47)\140)}";');''')`)}

Since escaping line breaks is difficult, I used semicolons to make it a one-liner of Go (When you write Go, you don't usually use semicolons at the end of statements, but Go compiler apparently adds them. Here I add semicolons manually to achieve the one-liner).
Also, by using backticks for the string, I can include single and double quotes within the string.

Running this Go code outputs the following Python code:

print(r'''<?=eval($_='print "package main;import\42fmt\42;func main(){fmt.Print(\140print(r\47\47\47<?=eval(\44_=\47$_\47);\47\47\47)\140)}";');''')

It is relatively straightforward, but by using ''', I can use single quotes within the string, and by using r''', I avoid the conversion from octal to ASCII.

Running this Python code brings us back to the original PHP.

<?=eval($_='print "package main;import\42fmt\42;func main(){fmt.Print(\140print(r\47\47\47<?=eval(\44_=\47$_\47);\47\47\47)\140)}";');

Summary

I thought a three-language Quine relay would be very difficult, but once I started writing it, it turned out to be simpler than expected.
I hope this article helps you read/write more quines 🙂

Encoding an Encoder for my own Encoding with the Encoder

Hideaki — Tue, 27 Jan 2026 09:06:11 +0000

Introduction

Some time ago, I made a joke encoding called Base8192. It looks like this:

Input: What is base8192?
Base8192: 卶晡啂幩唲幢吗慥冃弹儣洀等
Base64: V2hhdCBpcyBiYXNlODE5Mj8=

Base8192 utilises Chinese characters and uses fewer letters compared to Base64. In the example above, Base8192 uses only 13 characters, whereas Base64 needs 24 characters.

If you're curious how it works, here is the GitHub link to the repo and README explains more details.

https://github.com/karintomania/Base8192

So, I got an idea, implemented it and confirmed it works as expected.

But now what? What if I wanted to encode something more than just user-input text?

Self-Hosting Dream

I’ve heard that, in the world of making a compiler, compiling a compiler in your own compiler is a big milestone.

This is called self-hosting.

I decided to do something similar with my encoding: encoding an encoder with the encoder.

(Image:https://unsplash.com/photos/red-blue-and-yellow-ceramic-figurine-PB80D_B4g7c)

How it works

My original implementation of Base8192 is written in JavaScript. I chose it because I wanted to make an interactive demo website. You can try out from the link below:
https://karintomania.github.io/Base8192/

I want my new self-encoded encoder to be available in the website too, but it doesn't make sense to encode JavaScript code for the browser where you can run it directly.

But, there is another runtime in browsers: WASM.

To include a WASM binary in your code, there are a few ways to do it and encoding the binary and decoding it in JS is perfect for my case.

How to make WASM binary

Up until I started this challenge, I didn’t really know what WASM is. Apparently various languages can be compiled to WASM (even JS!).

My choice of language was zig. Simply because that is the language I've been playing with and its WASM support looks good.

Another choice could have been Moonbit and it’s a quite interesting language. But at this point, I started to learn too many languages, so I resisted my urge to learn something shiny 😅

So, the mental model of this project looks somewhat like the diagram below:

Rewrite the encoder in zig

Writing the same code in JavaScript and zig was a fun experience! These two languages are wildly different; JS is a high level, dynamically typed, scripting language with Garbage collector, whereas zig is a low level, statically typed, compiled language, with manual memory management.

To my surprise, the amount of code is not too different. The core logic of the JS version (base8192.js) contains 288 lines and the zig version (base8192.zig) contains 258 lines (excluding tests in the same file).

I expected zig code to have more lines given zig being a quite low level language! This is partially because my implementation in zig is a bit better as it’s my second iteration. But I think zig’s simple syntax helped to reduce the code volume.

Call WASM from JS

Now, let’s call the encode/decode function defined in the WASM from JS!

One thing you need to be careful about is that WASM functions can only return primitive types to JS.

My encode function wants to return string, and decode function wants to return a struct. Neither string nor struct is supported. What do I do?

To return a string, first we store the string as an array of 8-bit unsigned integers (u8) on WASM memory. Now, you somehow need to tell JS which address the string starts and the length of the string, so that the JS knows exactly where in the WASM memory to read.

Since you can only return 1 value in function, this is a bit tricky (I had to remind myself a few times I can’t return an object like {"address": xxx, "length": yyy} in WASM 😅).

One straightforward solution is to create 2 functions, which returns the pointer and the length. For Base8192 encoding, the length of the encoded string is determined by the input’s size, so this is feasible.

fn getEncodeResultLen(inputLength: u32) u32 {
    // rest of the logic
    // ...
    return length;
}

fn encode(input_ptr: [*]const u8, length: usize) ?[*]u8 {
  // encoding logic
  // ...
  return result; // return pointer
 }

But this doesn’t work well for decoding as we only know the result of decoding after the decoding is done. This is because when Base8192 detects invalid sequences, it skips them until it reaches valid data again. Therefore, the length is unknown until the decoding finishes.

What I did is to prefix the string with its length. It looks like below:

The function returns pointer to the prefixed string. JS reads the first 4 bytes (32bits) and it is the length of the output. Now, JS can read the string, starting from the fifth byte and for the given length.

For the decode function, I wanted to return the result string and the index of the detected errors (base 8192 is self synchronous, meaning it can detect errors and still can decode the rest of the input). It would be like this:

{
    "result": "Hello World!!",
    "errors": [2, 4]
}

I could do a similar approach, prefixing the result with length of result and errors array. But I got lazy 😅 and decided to just return JSON as string and prefix it with the length.

This comes with some performance penalty on JS side to run JSON.parse(), but I can take that trade-off for the ease of the implementation.

Encode the encoder in the encoding

Finally we can self-encode the encoder.

The code below reasd the encoder file and store it in sourceBinary. sourceBinary is now used to create a WASM instance and the input of the encode_w_binary function.

async function encode_self() {
    // Read the binary file
    const sourceBinary = fs.readFileSync("./zig-out/bin/base8192.WASM");
    const typedArray = new Uint8Array(sourceBinary);

        // create WASM instance from the binary
    const WASM = await WebAssembly.instantiate(typedArray, {env: {}});

    const WASMInstance = WASM.instance;
    const WASMMemory = WASMInstance.exports.memory;

    // encode the binary with the WASM instance
    const result = await encode_w_binary(sourceBinary, WASMInstance, WASMMemory);

        // write the JS string to encoder.js
    fs.writeFileSync("./encoder.js", `export const encoded = "${result}";`);
}

And here it is. The result is stored in encoder.js like below (I managed to fit 10,000+ characters into one screenshot):

Beautiful 😊

You can see the actual file on GitHub too: https://raw.githubusercontent.com/karintomania/Base8192/refs/heads/main/encoder.js

Benchmarking

Although performance is not the reason I used WASM, I expected some improvement with the WASM version of the encoder.

I created a 2 MB of csv file to measure how long it takes to encode it.

Here is the result:

	Speed (ms)	Memory Usage (MB)
JS	220	187
WASM	658	142

Memory usage is taken from time command’s Maximum resident set size.

Actually the JS version is faster! I ran the test multiple times but the result didn't change. I assume encoding is a kind of the task where JIT can do a great job.

Memory usage is lower in the WASM version as expected.

Optimising the WASM

I couldn’t accept the fact that my WASM is slower than JS 😅 and I remembered zig has multiple optimisation options.

Zig has a build option for optimisation and by specifying the option, you can get a binary which is optimised for something.

The standard options are:

Debug (Provide better debug info)
Fast (Optimised for speed)
Small (Optimised for binary size)
Safe (Optimised for memory safety)

The option I used was the small one. This is to make the binary small so that the demo site can be snappy to load. But for the benchmark, why not using the fastest option!

After using the release-fast option, this is the result.

	Speed (ms)	Memory Usage (MB)
JS	220	187
WASM (small)	658	142
WASM (fast)	183	140

This is like 350% faster (658 → 183ms) and WASM is now faster than JS! I’m really happy with this result.

Conclusion

If you are interested in Base8192, here is the interactive demo site, which runs the WASM binary:

https://karintomania.github.io/Base8192/

You might wonder the point of this article.

Will Base8192 replace Base64? No.

But after creating my own encoding and self-encoded the encoder, I learned more about encoding, WASM and a lot of low level stuff through zig!

I hope you enjoy this article.

Use variable variables of PHP to obfuscate code

Hideaki — Tue, 25 Nov 2025 17:33:19 +0000

I came across a weird PHP concept—variable variables.

It works like this:

$a = 'foo';
$$a='bar';
print $foo;

The variable $foo in line 3 is not directly declared. Instead, $$a in line 2 is interpreted as $foo because PHP expands the value of $a from line 1.

I use this feature to obfuscate this Quine in PHP:

<?php $SS='${"$$"}=" ";for($ss=33;$ss<127;$ss++)${chr($ss-1)}=chr($ss);
eval(preg_replace("/\s/","",substr($SS,132)));printf($_,$SS);#$$$$$$$$$
$_=$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"}.$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
{"$$"}.$$$$$$$$$$$$$$$$$$$$$$$$$      $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$${"$$"}.$$      $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$        $$$$$$${"$$"}.$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$                   $$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$${"$$"}.${"$                        $"}.$$$$${"$$"}.$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$                           $$$$$$$$$$$$$$$$$$$$$${
"$$"}.$$$$$$$$$$$$$$             $$              $$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$${"$$"             }.$$$            $$$$$$$$$$$$$$$$$$$$$$
$$$$${"$$"}.$$$$$$$             ${"$$             "}.$$$$$${"$$"}.$$$$$
$$$$$$$$$$$$$$$$$$$             $$$$$             $$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$              $$$$             $$$$$$$$$$${"$$"}.$$$
$$$$${"$$"}.$$$$$$$               $$$$$$$$$$$$$$$$$$$$${"$$"}.$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$                 $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$${"$$"}.$$$$$$$                    $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$                     $$$$$$$$$$$$$$$$$$$$$$$$$$$$
{"$$"}.$$$$$$$$$$$$$$$$$                      $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$${"                      $$"}.$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$                     $$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$${"$$"}.$$$$$$$$${"$$"}                   .$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$                 $$$$$$$$$$$$$$$$$$$$
$$$$$$$$$${"$$"}.$$            $$$$$               $$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$             $$$$$              $$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$${"$$             "}.$$              $$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$             $$$$$              $$$$$$$$$$$$$$$$$$$$
${"$$"}.$$$$$$$$$$$             $$$$$              $$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$            $$$$$             $$$$$$$$$$$$$$$$$$$$$
$${"$$"}.$$$$$$$$$$$$                            $$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$                          $$$$$$$$$$$$$$$$$$$$$$$
$$$$$${"$$"}.$$$$$$$$$$$                      $$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$                $$$$$$$$$$$$$$$$$$$${"$$"}.$
$$$$$$$${"$$"}.$$$$${"$$"}.$$$$$      $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$${"$$"}.$$$$$$$$$$$      $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$${"$$"}.$$$$$$$$$$$$${"$$      "}.$$$$$$$$$$$$$$$$${"$$"}.$$$$$$
$$$$$$${"$$"}.$$$$$$$$$$$$$$$$$${"$$"}.$$$$$$$$$$$$$$$$$$$${"$$"}.$$$$$
$$$$$$$$$$$$$${"$$"}.$$$$$$$$$${"$$"}.$$$$$$$$$${"$$"}.$$$$$$$$$$$$$$$$
$$$$$$$$$$$${"$$"};#$$$$$$$$$$$$$$$$$$$$$$$$$';eval(substr($SS,0,132));

The key part of this code is:

$SS='${"$$"}=" ";for($ss=33;$ss<127;$ss++)${chr($ss-1)}=chr($ss);

Firstly, PHP usually uses only alphanumeric characters and underscores for variable names. But if you use the ${} syntax, you can use pretty much any character for variable names, even the dollar sign itself.

${'$'} = 'dollar';
print ${'$'}; // dollar

Let's look at the Quine code again, cleaned up a bit:

${"$$"}=" ";

for($ss=33;$ss<127;$ss++){
    ${chr($ss-1)}=chr($ss);
}

This code creates an ASCII ↔ variable variable conversion.

The code starts with ${'$$'}=' ';. Note that space is ASCII code 32.

The for-loop creates variable variables that follow this pattern:

${[ASCII code N-1]} = '[ASCII code N]';

For example, when N=33, this code is interpreted as follows:

${' '}='!' (ASCII code 32 is space, 33 is !).

When N=34, it will look like ${’!‘}=’"’ and so on.

Now, because ! is defined as ${' '} and space is defined by ${'$$'}, ! can also be represented as $${'$$'} using variable variables. Likewise, " is $$${'$$'}, and so on.

After the for-loop is finished, all ASCII characters can be written as [$ for (ASCII code - 31) times]{'$$'}

Here are some examples:

print ${'$$'}; // space: ASCII 32
print $${'$$'}; // !: ASCII 33
print $$${'$$'}; // #: ASCII 34
print $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"} // A: ASCII 65
print $$$$$$$$$$$$$$$$$${"$$"} // 1: ASCII 49

Using this, a "Hello World" program looks like this:

<?php

${"$$"}=" ";

for($ss=33;$ss<127;$ss++){
    ${chr($ss-1)}=chr($ss);
}

print $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"}. // H
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"}. // e
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"}. // l
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"}. // l
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"}. // o
$$$$$$$$$$$$${"$$"}. // ,
${"$$"}.// ' '
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"}. // W
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"}. // o
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"}. // r
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"}. // l
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$${"$$"}. // d
$${"$$"}; // !

Note that you can't use single-letter variables in this code, such as $i for the counter. All single-letter variables are defined in the for loop (e.g., $i is defined as the string j).

Now, all that's left is to write a Quine using this technique, which gives us the code shown at the top of the article.

I hope you enjoyed this article. Happy coding!

How to Create Quine and Quine Relay Code

Hideaki — Sun, 19 Oct 2025 21:01:09 +0000

The first time I read the Wikipedia article about quines, I was trying to understand it but couldn't have figured it out. Looking back, I think it was because I was programming in Java at that point, and Java isn't the best language for writing quines.

Recently, I revisited the concept and it clicked this time. I can now understand how they work. In this article, I'll share everything I've learnt as simple as possible.

Note: I used AI to proofread my article, but I wrote all of the code in this article.

Anatomy of a Quine

In this article, I use Python because of its concise syntax and popularity. Once you understand the principles here, you can write quines in the language of your choice.

Here is the quine in Python, which we will create in this article:

s='s=%c%s%c; print(s%%(39,s,39)'; print(s%(39,s,39))

You can run this code in your browser using an online Python interpreter like https://pythononline.net/

Don't worry if you don't understand what's going on yet. I'll explain it step by step.

First Step: Data and Print

I want to build a quine incrementally, starting from the basics.

Here is the first version of the code.

# version 1
s="print(s)"
print(s)

# output
print(s)

This code simply prints the string print(s), but it already contains the two essential parts of a quine:

Data definition — storing the code as data
Data printing — outputting that data

s="print(s)" # data definition
print(s)     # printing data

The Paradox of Updating the Data Definition

Version 1 only prints the printing part. To turn this into a proper quine, we need to print the data definition as well. So I edited the code like this:

# version 2
s="""s="print(s)"
print(s)"""  # define data including data definition
print(s)     # print data

# output of version 2
s="print(s)"
print(s)

(I used Python's """ syntax to include a newline in the string.)

Now it prints the previous code. But here's the problem: because we changed the data definition, the original code is now different! This is the paradox that makes quines tricky. Every time you change the data to print the code, the code itself changes.

Include the Data in the Data Itself

If you look closely at version 2, you'll notice there are actually two data definitions: the actual definition and the one inside the double quotes.

# version 2
s="""s="print(s)"
print(s)"""
print(s)

# Its result
s="print(s)"
print(s)

↓ Outside definition:
s="""s="print(s)"
     ↑ Inside definition

The trick to making a quine work is to use the data from the outside definition to fill in the inside definition.

More specifically, in Python, you can use the % operator inside print() to insert values into strings:

print("I like %s!" % "Python")
# this prints "I like Python!"

If I apply this to our code, it would look like this:

# version 3
s="""s="%s"
print(s)"""
print(s%s) # Replace %s with the value of s

# output of version 3
s="s="%s"
print(s)"
print(s)

The output looks quite similar to the original code!

Tidy the Code

You're almost there! In the last section, you handled the core concept of quines. What's left is the somewhat tedious part: tidying up the code by dealing with special characters.

Let's look at version 3 again:

# version 3
s="""s="%s"
print(s)"""
print(s%s)

At this point, we need to handle special characters that can't be printed directly:

Newlines
Quotes
Percent symbols

In general, I prefer to make quines one-liners to keep the code simpler. If the code includes a newline, the data needs to be quoted specially in most languages (like the triple quotes in Python).

So I removed the newline and used a semicolon instead. Since we no longer need triple quotes, I replaced them with single quotes.

# version 4
s='s='%s'; print(s)'; print(s%s)

But this code causes a syntax error because you can't use a single quote inside single quotes.
In normal programming, you could escape the quote, but in a quine, that doesn't work because the output would have a syntax error.

# version 4.1
s='s=\'%s\'; print(s)'; print(s%s) # this is correct

# output
s='s='%s'; print(s)'; print(s) # syntax error!

One way to handle this is to use %c in the format string, just like we used %s to expand the data.

# version 4.2
s='s=%c%s%c; print(s)'; print(s%(39,s,39))

# output
s='s=%c%s%c; print(s)'; print(s)

The magic number 39 is the ASCII code for a single quote.

What's left is the printing part inside the data: print(s%(39,s,39)).

The only tricky bit here is that you need to escape the percent sign in the data. Luckily, you can just use double percent (%%) to escape it.

Here's the final version and it's a proper quine!

# version 5
s='s=%c%s%c; print(s%%(39,s,39))'; print(s%(39,s,39))

# output
s='s=%c%s%c; print(s%%(39,s,39))'; print(s%(39,s,39))

Quine Relay

Now that we know how to write a quine, let's take it to the next level!

A quine relay is a program that prints code in a different language, which prints code in yet another language, and so on until it eventually prints the original code again.

I'll create a quine relay between Python and PHP, walking through the process step by step.

Python Printing PHP

Here's version 1:

# version 1
s='here is some python code';print('<?php print("%s");' % s)

# result
<?php print("here is some python code;");

The printed result is actually valid PHP code. The idea here is that instead of printing "here is some python code", we want the PHP code to print the original Python code.

Let's replace the content of variable s with a more realistic value.

# version 2
s='s=\'%s\';print(\'<?php print(%s);\' %% s)';print('<?php print("%s");' % s)

# result PHP
<?php print("s='%s';print('<?php print(%s);' %% s)");

# result of result PHP
s='%s';print('<?php print(%s);' %% s)

Hopefully you can see where we're going. If you look at the final result, you'll notice we only need to replace the first %s with the value of s from the original code.

Add Self-Replicating Code

So I added the replacement:

# Version 3
s='s=\'%s\';print(\'<?php print(%%s);\' %% s)';print('<?php print("%s");' % (s%s))

# result PHP
<?php print("s='s='%s';print('<?php print(%%s);' %% (s%%s))';print('<?php print(%s);' % (s%s))");

This part is where the magic happens.

print('<?php print("%s");' % (s%s))

(s%s) is expanding s inside s itself, and the result gets added to the PHP code output.

The string that PHP is trying to print is quite close to the original Python code, but the PHP code itself is no longer valid. Let's fix the escaping.

After some trial and error, I managed to make the escaping work:

# Version 4
s="s=%r;print('<?php print(%%r);' %% (s%%s))";print('<?php print(%r);' % (s%s))

# Result PHP
<?php print('s="s=%r;print(\'<?php print(%%r);\' %% (s%%s))";print(\'<?php print(%r);\' % (s%s))');

# Result Python of Result PHP
s="s=%r;print('<?php print(%%r);' %% (s%%s))";print('<?php print(%r);' % (s%s))

The trick here is Python's %r formatter. This is similar to %s, but it prints strings as valid Python code, automatically handling quote escaping for you.

Obfuscate the Code

You'll notice that many quine examples online are somewhat obfuscated, so let's make our quine relay harder to read. This is a rare opportunity—in your day job, you don't normally get to obfuscate your code!

First, I'll use _ instead of s as the variable name to make the code look more eccentric. We can also remove all unnecessary whitespace.

# Version 5
_="_=%r;print('<?php print(%%r);'%%(_%%_))";print('<?php print(%r);'%(_%_))

In PHP, you can also use a shorthand syntax: instead of <?php print("something");, you can write <?="something"?>.

Here's my final version of the quine relay:

# Version 5
_="_=%r;print('<?=%%r?>'%%(_%%_))";print('<?=%r?>'%(_%_))

# Result PHP
<?='_="_=%r;print(\'<?=%%r?>\'%%(_%%_))";print(\'<?=%r?>\'%(_%_))'?>

Conclusion

Quines available online are often optimised for strangeness most of the time (which is cool, but not good for explanation purposes 😅).
Hopefully this article helped you to understand this strange and beautiful concept in a readable code.

To be fair, once I understood the concept, what I enjoyed the most was obfuscating the code. What I learned from this experience is that reading obfuscated code is much harder than writing obfuscated code. So, I might write another article about explaining tricky code!

Thanks for reading 😆

Reference

If you are interested in writing your own quines, these articles are useful and inspiring.
Wikipedia quine

Quine How To

Quine relay with 128 languages

How to Handle HTTP Responses with the Stream+JSON Content Type Using PHP Generators

Hideaki — Tue, 06 May 2025 16:04:53 +0000

In this article, I'll discuss:

What Content-Type: stream+json is
How to handle stream+json responses with PHP

The sample code is fully open source and available here:

👉 GitHub Repository

If you have Docker Compose installed on your machine, you can run the code without installing anything extra.

What is Content-Type: stream+json?

Before we dive into coding, let's quickly explore why stream+json exists. Often, you need to send large arrays of JSON via APIs. You could send this large array from the server all at once, but when PHP receives it, PHP loads everything into memory.

While this method works, it can cause issues such as:

High memory consumption
Risk of timeout ⏳

How to solve these problems?

💡Solution: Content-Type: stream+json

To tackle these issues, the stream+json content type is used. For this content type, the server sends a "stream" of data, which consists of lines of JSON in this case.

See the GIF below, which shows how a server can send JSONs on a stream with Content-Type: stream+json.

As you can see, the server is sending JSON line-by-line.

This format is called JSON Lines (or JSONL for short), which is a newline-separated JSON. JSONL allows data to be processed line-by-line, making it easier to handle large JSON objects efficiently.
Because each line is a valid JSON, PHP can start processing the object as it receives it, without waiting for the whole response.

In summary, using Content-Type: stream+json allows the program to:

Start processing immediately without waiting for the entire response ⏩
Use less memory by processing JSON one by one, instead of dealing with a massive array of JSON

Receiving the Stream+JSON Response as a Stream with Guzzle

Now, let's talk about how to handle a stream+json response.

Before diving into the implementation, it's important to clarify a common point of confusion:

PHP has built-in functions called Streams. This stream refers to a way to manage resources like files or HTTP in a unified manner. However, the "stream" discussed in this article refers to HTTP responses using the stream+json content type.

More about PHP's built-in streams: PHP Streams Documentation

Fortunately, the Guzzle library has a handy "stream" option to get the response as a stream. All you need to do is set this 'stream' option to true.

use GuzzleHttp\Client;

$client = new Client();
// Enable the stream option
$response = $client->get('http://localhost', ['stream' => true]);

// getBody() retrieves the response as a stream
$stream = $response->getBody();

If you run the code above, you will have the response as a stream, more specifically as a StreamInterface. StreamInterface is defined by PSR-7 as an interface for data streams. If you want to know more about this interface, see the link below for details:

StreamInterface Documentation

One of the important methods of "StreamInterface" is the read(int $length) method, which allows you to retrieve content of the specified length. We will see how to handle the JSON stream line by line using this method in the next section.

Note that if you don't set the stream option, the getBody() function will wait for the whole response and return it as a string.

Handling the Stream with PHP Generators

Since the stream sends JSON line-by-line, using a Generator is an efficient approach, as it allows the consumer to process each object one by one.

Here's a class that demonstrates how to process the stream and return JSON-decoded objects using a Generator:

<?php

namespace StreamTest;

use Psr\Http\Message\StreamInterface;
use \Generator;

class StreamScanner {
    private const CHUNK_SIZE = 8192;

    /**
    * @return Generator<object>
    *
    * Read each line from the stream and return it as an object.
    * Each line will be a JSON object.
    */
    public function __invoke(StreamInterface $stream): Generator
    {
        foreach ($this->nextLine($stream) as $line) {
            yield json_decode($line);
        }
    }

    /**
     * @return Generator<string>
     *
     * Read each line from the stream.
     */
    private function nextLine(StreamInterface $stream): Generator
    {
        $buffer = '';

        // Read chunks until EOF
        while (!$stream->eof()) {
            $buffer .= $stream->read(self::CHUNK_SIZE);

            // If buffer has a newline, yield a JSON line
            while (($pos = strpos($buffer, "\n")) !== false) {
                // Get the complete JSON
                $line = substr($buffer, 0, $pos + 1);
                $buffer = substr($buffer, $pos + 1);
                yield $line;
            }
        }

        // Process any remaining buffer
        if ($buffer !== '') {
            yield $buffer;
        }
    }
}

Let's break down this code a bit.

`__invoke` Method

This method returns a generator of JSON-decoded objects. It retrieves each line from the nextLine method and applies json_decode() to convert the JSON string into an object.

`nextLine` Method

This method processes the stream in chunks and identifies complete lines by searching for newline characters. It continues reading until the end of the file is reached, ensuring that all lines are processed.

Note on `GuzzleHttp\Psr7\Utils::readLine` Method

Guzzle offers Utils::readLine() function, which works like my StreamScanner.

https://github.com/guzzle/psr7/blob/2.7/src/Utils.php#L234

This function, as the name suggests, reads one line from the stream. The differences from the StreamScanner in this article are:

It returns a string, instead of a Generator.
The implementation reads the stream one character at a time.

Because it reads the stream one character at a time instead of reading chunks, this function can be slow.

I processed a JSONL file with 100K lines using both implementations and the result is:

StreamScanner: 0.049s
Utils::readLine: 0.416s

Utils::readLine is very useful when the file is not large or the speed is not your concern (like batch jobs, for example). Also, if you can't use Generators, you should use Utils::readLine.

Testing the Implementation

Let's talk about testing. Mocking the stream for testing purposes is actually not too hard.

For testing purposes, Guzzle offers a convenient function called Utils::streamFor(), which converts a resource into a StreamInterface. This is particularly useful for testing your stream handling logic.

For example, if you have a JSON file that resembles the actual payload of the response, you can write something like this:

$f = fopen(__DIR__ . '/data.json', 'r');
$stream = Utils::streamFor($f);

Now you have the stream. If you are using Guzzle to make the request, you can mock the Guzzle client to return this stream. It's another benefit of using PSR-defined interfaces, as it protects the code from implementation details.

Conclusion

The stream+json content type, utilizing the JSONL format, is a powerful solution for managing extensive HTTP responses. By employing streams and generators, you can create memory-efficient code capable of handling large data sets with ease.

All of the sample code and more examples are available in my GitHub repo:

👉 GitHub Repository

I hope this article helps you. Happy coding! 😊

My Experience of Letting AI Handle a Whole PR Without Touching the Code

Hideaki — Tue, 06 May 2025 08:53:08 +0000

Today, I want to share my experience using Cline (https://github.com/cline/cline) to manage an entire pull request (PR) without touching the code myself.

Rules

I set the following rules for myself to complete the PR:
Only let the AI write the code. Editing the code generated by the AI was not allowed.
Use Cline as much as possible to let the AI handle everything. If it didn't work, use Copilot Chat. As a last resort, copy and paste from the web version of ChatGPT.
Running commands like linting by myself was allowed. (It's just faster to run the commands myself than telling AI to run the exact command.)

The task I chose for the AI was a refactoring task to unify the implementation of mocking across the codebase, which varied by developer.

Environment

I used the vanilla Cline VS Code extension.
I tried the following two models:

vscode-lm:copilot/gpt-4
vscode-lm:copilot/gpt-4o

The codebase was an average Laravel application.

Positives

The PR was completed without touching the code.

The task was completed entirely through prompts. I wasn't sure if it was possible, but Cline made it. This was a different experience from Copilot, where once the prompt was written, the AI handled everything.

The AI can handle tasks beyond just writing code

Cline was able to handle various tasks beyond just reading and writing code.

Here are some tasks I asked it to do:

Use ripgrep to find refactoring points
Run tests to verify the correctness of the code and fix errors if any
Format the code to a consistent style
Generate Git commits, comments, and PR descriptions from git diff
Write blog posts from notes I took during experiments (like this article!)

These techniques are useful and something I plan to use in my day-to-day tasks.

Negatives

The biggest negative point was that honestly, it felt faster and easier to write the code myself.

AI is not that smart yet

The task was relatively simple, unifying the implementation of mocks, but the AI struggled to understand the intent of the prompts and the existing code. It often made unrelated changes or misunderstood what it meant to do.

There were also many instances where it got stuck in an infinite loop, repeatedly fixing the same error.
Additionally, I had to include sample code in the prompt to show the correct way to write mocks. This might be because many PHP codes are written without tests, so AI doesn't have enough training data.

Prompt engineering is challenging

Related to the above, prompt engineering is necessary to correctly convey what you want the AI to perform.
Here is the prompt I used, which is very long and specific.
It took trial and error to reach the final version.
I believe I could have finished the task myself in the time it took to write this prompt.

# Prompt
In the tests/ folder, I want to unify how mocking is implemented.

# Rules
- There are instances of using mock(), Mockery::mock(), or $this->mock().
- Don't change anything apart from mock(), Mockery::mock(), or $this->mock() even if you find an error or improvements.

## mock()
- Keep mock() if it only has a first argument.
- If it has an anonymous function to make assertions for the second argument, remove the second argument and add lines to do the equivalent.
- The mock should look like below without comments:
$mock = mock(UserRepository::class); // create mock. Only use the first argument

$mock->shouldReceive('function name') // insert function name to mock
->with('expected input') // insert expected args if applicable
->andReturn('expected output') // insert expected output if applicable
->once();

## Mockery::mock()
- Change it to use mock() and do the same for mock()

## $this->mock()
- Change it to use mock()
- Add app()->instance()/app()->bind() to bind the mock to the mocked class
- Prefer to use app()->instance(). But when instantiation needs to pass arguments, use app()->bind() and pass an anonymous function for the second argument.

# Contexts
- This is a Laravel app and uses Pest as a testing library.
- It uses Mockery for mocking.
- You can verify if the test passes or not by running `make test-unit && make test-feature`
- You can check the use of $this->mock or Mockery::mock by running these commands:
+ rg '\$this->mock' tests/
+ rg Mockery::mock tests/

Code generation is quite slow

When using GPT-4, it took quite a while for the actual code diff to be presented. GPT-4o was faster than GPT-4, but it still sometimes stopped generating code.

Also, when the file itself was large, even a single line change would make the AI generate the entire file. Because of this, in my machine, editing files with 500+ lines failed.
Therefore, when changing only part of a large file, it was sometimes faster to use Copilot Chat, which can show only the diff.
These points are still frustrating compared to normal coding, but I believe they will be resolved as models improve in the future.

Bonus

Here are some useful prompts I found.

Create a commit

Read the staging changes by running `git --no-pager diff --staged` and commit it with an appropriate message.
Make the first line concise and add details after a newline if necessary
When letting Cline read the git command results, use the ` - -no-pager` option to avoid having to scroll the command result manually.

Create PR details

When creating a PR on GitHub, there is usually a project template, and this prompt can automatically fill it out.

Compare the diff between the current branch and master branch and fill this template for PR.

# Title
Title for this PR
# Motivation
The motivation of this PR
# Description
Details of the PR.

Conclusion

Overall, I found it more useful than I expected.
Although there are still some frustrating points, I believe that with faster and smarter models in the future, AI coding might become mainstream.
Happy coding (or prompting)!

DEV Community: Hideaki

Creating a PHP, Go, and Python Quine Relay

Summary

Encoding an Encoder for my own Encoding with the Encoder

Introduction

Self-Hosting Dream

How it works

How to make WASM binary

Rewrite the encoder in zig

Call WASM from JS

Encode the encoder in the encoding

Benchmarking

Optimising the WASM

Conclusion

Use variable variables of PHP to obfuscate code

How to Create Quine and Quine Relay Code

Anatomy of a Quine

First Step: Data and Print

The Paradox of Updating the Data Definition

Include the Data in the Data Itself

Tidy the Code

Quine Relay

Python Printing PHP

Add Self-Replicating Code

Obfuscate the Code

Conclusion

Reference

How to Handle HTTP Responses with the Stream+JSON Content Type Using PHP Generators

What is Content-Type: stream+json?

Receiving the Stream+JSON Response as a Stream with Guzzle

Handling the Stream with PHP Generators

__invoke Method

nextLine Method

Note on GuzzleHttp\Psr7\Utils::readLine Method

Testing the Implementation

Conclusion

My Experience of Letting AI Handle a Whole PR Without Touching the Code

Rules

Environment

Positives

The PR was completed without touching the code.

The AI can handle tasks beyond just writing code

Negatives

AI is not that smart yet

Prompt engineering is challenging

Code generation is quite slow

Bonus

Create a commit

Create PR details

Conclusion

`__invoke` Method

`nextLine` Method

Note on `GuzzleHttp\Psr7\Utils::readLine` Method