I've been working in this brainfuck++ compiler a couple of days ago (if there were no schools, it would've taken only a day lol) and now it's done. The compiler emits only x86-64 bit executable yet.

New features I added:
- Registers (=n, $n)
- Random (?)
- Exec (!)

Detailed docs about the language, and installation of the compiler is mentioned in the repto which you can checkout from here.

Very old project that i've done years ago just by curiosity; It converts string passed in the first argument and converts to BF instruction

In Urban Mueller's original bf interpreter (copy available here on Aminet as LhA archive: https://aminet.net/package/dev/lang/brainfuck-2 ) there's a mysterious "o" variable. It is initialized to 1 inside a switch header, switch (o=1, *c++) { …, which is already a bit odd looking, but perfectly legal C, and then later just set back to 0 in the default: case. I assume this deals with some fancy quirk or optimization trick of the old C compiler from that era. Anyone knows more about it and has a proper explanation?

I have recently written a brainfuck interpreter, which is mostly for education purposes and a little bit of fun but that is beside the point. My question is, is there a reliable source for a specification for the language?

Like, for example, if the stack pointer is pointing at the first element, what behaviour would occur if a "<" is encountered? If a "," is encountered, should the input be processed in canonical mode (input is only passed through when enter is pressed), or in immediate mode?

Essentially, is there some sort of implicit behaviour that everyone expects, or is there leeway for interpreter-specific implementation?

drive.google.com/drive/folders/1LqIPSkoyVm8MARSib0sNifjgJcGz6HJs

>>>>,[<+<+>>-]<[->+<[-[>]]<<]>[-->>[-<]<<+>]
[+<++<-[>]]<[<]>>[>+<[+]]>[<<-<+>>>-]

The result of the division is in the 2nd cell and the remainder is in the 1st.

i need a bf compiler for aarch64

++++++++++>,[+++.<..>---,]

The idea is simple:
if the current cell=12 move 12 left
If it equals 25 move 25 left
Etc
I need a program that can move left once for each “point” in the cell
There is important data in that area, so it has to be not disruptive

Any ideas?
(if your solution works you will be featured in the credits for the game I’m using this for)

I have written some simple BF code here to let a user type in something and the program prints it back out. Ignoring how bad it probably is for now, the first dot just isn't working. Is this a BF thing, or a compiler issue or what? Any help is appreciated.

+[>,.-------------]<[<]>[+++++++++++++.>]

Hey hello everyone.

I'm actually working on a bf compiler for a Bachelor project and I have actually been surprised by the fact it was producing not so slow executables (Actually compiling into i386 assembly code and then assembling/linking for linux)

For example, it's taking around 1.8s on the Mandelbrot program.

I don't know if there's existing benchmarks somewhere (but anyway it depends a lot of the environment/CPU - I've a ryzen 7 5700u and using wsl2)

Do you have any idea to help me check if my compiler is actually worse working on ? (Like modern bf compilers or stuff to compare) ?

Thanks in advance ^^

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.

Hi! I'm looking for a brainfuck interpreter that does not reset the memory when you run a program several times. I want my code to process the same memory multiple times. Does anybody know one?

-[------->+<]>.+[--->+<]>.+++++.----------.-----.+.-[->+++<]>.------------.--[->++++<]>-.[->+++<]>.--[--->+<]>-.[->+++<]>++.+++++++++++++.+++++.------------.--[--->+<]>--.-[--->++<]>+.+++.+.++++++++.+[---->+<]>++.--[->++++<]>-.+[->+++<]>.-------.--[--->+<]>-.+[--->+<]>.-[->+++<]>+.+[---->+<]>+++.[->+++<]>++.+++..+++++++++.-[->+++++<]>-.++[->+++<]>+.++++++++.------.+++++.-------.-[--->+<]>--.+++++[->+++<]>.-.>++++++++++.[------>+<]>.++[->++++<]>+.--[--->+<]>-.-[--->++<]>+.+++.+.++++++++.+[---->+<]>++.---[->++++<]>.------------.---.--[--->+<]>-.++[->+++<]>+.------.++++++++++++.--------.-[->+++<]>.------------.[->+++<]>+.+++++++++++++.----------.-[--->+<]>-.--[->++++<]>-.[->+++<]>.---[->+++<]>+.-[->+++<]>.-------------.--[--->+<]>-.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.[-->+++++++<]>.----.-----------.+[--->+<]>+++.-[---->+<]>++.-[--->++<]>-.+++++++++++.>++++++++++.++[++++>---<]>.-[->++++<]>.-[--->++<]>.+++++++++++.--.+.[---->+<]>+++.--[->++++<]>-.-[->+++<]>-.+++++++++++++..-------------.-[->+++<]>.---[->++++<]>.+++[->+++<]>.+++++++..[++>---<]>--.--[->++++<]>+.----------.++++++.-[---->+<]>+++.-[--->++<]>--.+++++++.++++++++.+[---->+<]>++.++++[->++<]>+.+[-->+<]>++.---[->+++<]>+.[->+++++<]>-.++[->+++<]>.-..+++++++.---.+++++.-------.>++++++++++.[->+++++++<]>+.[--->+<]>++.+++++..+[->+++<]>++.-[->+++<]>.+[----->+<]>.------------.++++++++++.------.--[--->+<]>-.--[->++++<]>+.----------.++++++.-[---->+<]>+++.---[->++++<]>+.-------.----------.+.+++++++++++++.+.+.+[->+++<]>++.+++++++++++++.----------.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.++[->+++<]>+.++.[->++++++<]>.+[->+++<]>.--[--->+<]>-.--[->++++<]>+.----------.++++++.-[---->+<]>+++.---[->++++<]>+.-----.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.++[--->++<]>.-------.[--->+<]>---.[---->+<]>+++.--[->++++<]>+.----------.++++++.-[---->+<]>+++.+[->+++<]>+.+++++++++++.++++++++.---------.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[----->++<]>.+++.-------.-[->+++++<]>-.[->+++<]>+.--[--->+<]>---.---.++++++.-------.----------.-[--->+<]>-.[->+++<]>+.+++++++++++++.----------.-[--->+<]>-.+[->+++<]>+.+.[--->+<]>----.++++[->+++<]>.+++++++++++++.++.[---->+<]>+++.--[->++++<]>+.----------.++++++.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.+[----->+<]>.------------.++++++++++.------.--[--->+<]>-.--[->++++<]>+.----------.++++++.-[---->+<]>+++.+[->+++<]>.-[--->+<]>----.+++++++.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[->++++<]>-.++[->+++<]>++.+[--->+<]>+++.-[---->+<]>++.++[->+++<]>+.++++++++..-----------.--.[--->+<]>+++.--[->+++<]>.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[->++++<]>.+++[->+++<]>.+++++++..[++>---<]>--.[->+++<]>+.-[->+++<]>.++[--->++<]>.---.----.--[--->+<]>-.[->+++<]>+.+++++++++++++.----------.-[--->+<]>-.-[--->++<]>--.[--->+<]>---.---.++.[---->+<]>+++.--[->++++<]>+.----------.++++++.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.++[->+++<]>+.++.[->++++++<]>.+[->+++<]>.--[--->+<]>-.--[->++++<]>+.----------.++++++.-[---->+<]>+++.---[->++++<]>+.-----.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.++[--->++<]>.-------.[--->+<]>---.[---->+<]>+++.--[->++++<]>+.----------.++++++.-[---->+<]>+++.+[->+++<]>+.+++++++++++.++++++++.---------.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[----->++<]>.+++.-------.-[->+++++<]>-.[->+++<]>+.--[--->+<]>---.---.++++++.-------.----------.-[--->+<]>-.[->+++<]>+.+++++++++++++.----------.-[--->+<]>-.+[->+++<]>+.+.[--->+<]>----.++++[->+++<]>.+++++++++++++.++.[---->+<]>+++.--[->++++<]>+.----------.++++++.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.+[----->+<]>.------------.++++++++++.------.--[--->+<]>-.--[->++++<]>+.----------.++++++.-[---->+<]>+++.+[->+++<]>.-[--->+<]>----.+++++++.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[->++++<]>-.++[->+++<]>++.+[--->+<]>+++.-[---->+<]>++.++[->+++<]>+.++++++++..-----------.--.[--->+<]>+++.--[->+++<]>.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[->++++<]>.+++[->+++<]>.+++++++..[++>---<]>--.[->+++<]>+.-[->+++<]>.++[--->++<]>.---.----.--[--->+<]>-.[->+++<]>+.+++++++++++++.----------.-[--->+<]>-.-[--->++<]>--.[--->+<]>---.---.++.[---->+<]>+++.--[->++++<]>+.----------.++++++.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.++[->+++<]>+.++.[->++++++<]>.+[->+++<]>.--[--->+<]>-.--[->++++<]>+.----------.++++++.-[---->+<]>+++.---[->++++<]>+.-----.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.++[--->++<]>.-------.[--->+<]>---.[---->+<]>+++.--[->++++<]>+.----------.++++++.-[---->+<]>+++.+[->+++<]>+.+++++++++++.++++++++.---------.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[----->++<]>.+++.-------.-[->+++++<]>-.[->+++<]>+.--[--->+<]>---.---.++++++.-------.----------.-[--->+<]>-.[->+++<]>+.+++++++++++++.----------.-[--->+<]>-.+[->+++<]>+.+.[--->+<]>----.++++[->+++<]>.+++++++++++++.++.[---->+<]>+++.--[->++++<]>+.----------.++++++.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.+[----->+<]>.------------.++++++++++.------.--[--->+<]>-.--[->++++<]>+.----------.++++++.-[---->+<]>+++.+[->+++<]>.-[--->+<]>----.+++++++.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[->++++<]>-.++[->+++<]>++.+[--->+<]>+++.-[---->+<]>++.++[->+++<]>+.++++++++..-----------.--.[--->+<]>+++.--[->+++<]>.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[->++++<]>.+++[->+++<]>.+++++++..[++>---<]>--.[->+++<]>+.-[->+++<]>.++[--->++<]>.---.----.--[--->+<]>-.[->+++<]>+.+++++++++++++.----------.-[--->+<]>-.-[--->++<]>--.[--->+<]>---.---.++.[---->+<]>+++.--[->++++<]>+.----------.++++++.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.++[->+++<]>+.++.[->++++++<]>.+[->+++<]>.--[--->+<]>-.--[->++++<]>+.----------.++++++.-[---->+<]>+++.---[->++++<]>+.-----.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.++[--->++<]>.-------.[--->+<]>---.[---->+<]>+++.--[->++++<]>+.----------.++++++.-[---->+<]>+++.+[->+++<]>+.+++++++++++.++++++++.---------.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[----->++<]>.+++.-------.-[->+++++<]>-.[->+++<]>+.--[--->+<]>---.---.++++++.-------.----------.-[--->+<]>-.[->+++<]>+.+++++++++++++.----------.-[--->+<]>-.+[->+++<]>+.+.[--->+<]>----.++++[->+++<]>.+++++++++++++.++.[---->+<]>+++.--[->++++<]>+.----------.++++++.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.+[----->+<]>.------------.++++++++++.------.--[--->+<]>-.--[->++++<]>+.----------.++++++.-[---->+<]>+++.+[->+++<]>.-[--->+<]>----.+++++++.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[->++++<]>-.++[->+++<]>++.+[--->+<]>+++.-[---->+<]>++.++[->+++<]>+.++++++++..-----------.--.[--->+<]>+++.--[->+++<]>.>++++++++++.+++[->++++++<]>.>--[----->+<]>-.[--->+<]>-.+[->+++<]>.+++++++++++++.[-->+++++<]>+++.++[->+++<]>+.++++++++.-..-------------.-[->+++<]>.---[->++++<]>.+++[->+++<]>.+++++++..[++>---<]>--.[->+++<]>+.-[->+++<]>.++[--->++<]>.---.----.--[--->+<]>-.[->+++<]>+.+++++++++++++.----------.-[--->+<]>-.-[--->++<]>--.[--->+<]>---.---.++.[---->+<]>+++.--[->++++<]>+.----------.++++++.

I looked at it and looks all nonsense and I tried writing down the memory and I have no clue what it is doing. Can anyone help me?

Edit: The code is ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>-+[<]<-].>---.+++++++..+++..<-.<.+++.------.--------.+.>++ I didn't have time to write this

I made a brainfuck optimizing compile which takes brainfuck code from a .b or .bf file and outputs an assembly file, which can be "linked" to a provided runtime using a C++ compiler.

BOCBWN - Brainfuck Optimizing Compiler Because Why Not

Note: if you're downloading the repo, the examples folder named bf/ is 2.2MiB (36x the size of everything else combined), so consider only downloading src/, bfbpl and the README.md if that's a problem.

It allows compilation to a *.bfvm intermediate file, and also outputs the intermediate in a more human-redable *.bfasm file. Its optimizations include first converting the brainfuck to an intermediate representation (IR) which is stored in a tree (AST) a conservative dry run over the program in which constant folding, some strength reduction, and dead code elimination occur, and more passes for liveness checking and more strength reduction. The AST is then converted back to a linear IR, which is converted to assembly by the (currently unoptimized) compiler.

The code for optimization is heavily commended (mostly because I needed to mentally lay everything out before doing it), so it should be (more-or-less) simple to understand the code.

Planned optimizations on the assembly backend with adding support for Windows in the near future, and further optimizations (check the `main` branch) and a debugger in the future.

Hello, guys! I have not posted anything on this sub-reddit for 4 months and it is quite refreshing to be here.

I have created my Brainfk interpreter in x86 Assembly (just pure assembly, no integration of other languages such as python or c). It uses 20,000 memory cells for now but I use 256 cells for now as I used cut it down to 256 memory cells for my small interpreter (I use resb). It is working now, at least. However, it pre-scans brackets and linearly scans them, which is inefficient for large codes.

Please the notes to understand it. Imma release my other bfk interpreters in the future. I suddenly deleted it as the readability is very bad.

Here's my link: https://github.com/clarklclark788-web/x86-Assembly-Projects-New-/tree/main

Practical Explanation ( For Example ) :- `1st of all can you tell me every single seconds detail from that time when you born ?? ( i need every seconds detail ?? that what- what you have thought and done on every single second )

can you tell me every single detail of your `1 cheapest Minute Or your whole hour, day, week, month, year or your whole life ??

if you are not able to tell me about this life then what proof do you have that you didn't forget your past ? and that you will not forget this present life in the future ?

that is Fact that Supreme Lord Krishna exists but we posses no such intelligence to understand him.

there is also next life. and i already proved you that no scientist, no politician, no so-called intelligent man in this world is able to understand this Truth. cuz they are imagining. and you cannot imagine what is god, who is god, what is after life etc.

_______

for example :Your father existed before your birth. you cannot say that before your birth your father don,t exists.

So you have to ask from mother, "Who is my father?" And if she says, "This gentleman is your father," then it is all right. It is easy.

Otherwise, if you makes research, "Who is my father?" go on searching for life; you'll never find your father.

( now maybe...maybe you will say that i will search my father from D.N.A, or i will prove it by photo's, or many other thing's which i will get from my mother and prove it that who is my Real father.{ So you have to believe the authority. who is that authority ? she is your mother. you cannot claim of any photo's, D.N.A or many other things without authority ( or ur mother ).

if you will show D.N.A, photo's, and many other proofs from other women then your mother. then what is use of those proofs ??} )

same you have to follow real authority. "Whatever You have spoken, I accept it," Then there is no difficulty. And You are accepted by Devala, Narada, Vyasa, and You are speaking Yourself, and later on, all the acaryas have accepted. Then I'll follow.

I'll have to follow great personalities. The same reason mother says, this gentleman is my father. That's all. Finish business. Where is the necessity of making research? All authorities accept Krsna, the Supreme Personality of Godhead. You accept it; then your searching after God is finished.

Why should you waste your time?

_______

all that is you need is to hear from authority ( same like mother ). and i heard this truth from authority " Srila Prabhupada " he is my spiritual master.

im not talking these all things from my own.

___________

in this world no `1 can be Peace full. this is all along Fact.

cuz we all are suffering in this world 4 Problems which are Disease, Old age, Death, and Birth after Birth.

tell me are you really happy ?? you can,t be happy if you will ignore these 4 main problem. then still you will be Forced by Nature.

___________________

if you really want to be happy then follow these 6 Things which are No illicit s.ex, No g.ambling, No d.rugs ( No tea & coffee ), No meat-eating ( No onion & garlic's )

5th thing is whatever you eat `1st offer it to Supreme Lord Krishna. ( if you know it what is Guru parama-para then offer them food not direct Supreme Lord Krishna )

and 6th " Main Thing " is you have to Chant " hare krishna hare krishna krishna krishna hare hare hare rama hare rama rama rama hare hare ".

_______________________________

If your not able to follow these 4 things no illicit s.ex, no g.ambling, no d.rugs, no meat-eating then don,t worry but chanting of this holy name ( Hare Krishna Maha-Mantra ) is very-very and very important.

Chant " hare krishna hare krishna krishna krishna hare hare hare rama hare rama rama rama hare hare " and be happy.

if you still don,t believe on me then chant any other name for 5 Min's and chant this holy name for 5 Min's and you will see effect. i promise you it works And chanting at least 16 rounds ( each round of 108 beads ) of the Hare Krishna maha-mantra daily.

____________

Here is no Question of Holy Books quotes, Personal Experiences, Faith or Belief. i accept that Sometimes Faith is also Blind. Here is already Practical explanation which already proved that every`1 else in this world is nothing more then Busy Foolish and totally idiot.

_________________________

Source(s):

every `1 is already Blind in this world and if you will follow another Blind then you both will fall in hole. so try to follow that person who have Spiritual Eyes who can Guide you on Actual Right Path. ( my Authority & Guide is my Spiritual Master " Srila Prabhupada " )

_____________

if you want to see Actual Purpose of human life then see this link : ( triple w ( d . o . t ) asitis ( d . o . t ) c . o . m {Bookmark it })

read it complete. ( i promise only readers of this book that they { he/she } will get every single answer which they want to know about why im in this material world, who im, what will happen after this life, what is best thing which will make Human Life Perfect, and what is perfection of Human Life. ) purpose of human life is not to live like animal cuz every`1 at present time doing 4 thing which are sleeping, eating, s.ex & fear. purpose of human life is to become freed from Birth after birth, Old Age, Disease, and Death.

++++++++[>+++++++++<-]>.[-]<++++++++++[>++++++++++<-]>+.[-]<++++++++++[>++++++++++<-]>++++++++..[-]<++++++++++[>+++++++++++<-]>+.[-]<++++[>++++++++++<-]>++++.[-]<+++[>++++++++++<-]>++.[-]<++++++++++[>+++++++++++<-]>+++++++++.[-]<++++++++++[>+++++++++++<-]>+.[-]<++++++++++[>+++++++++++<-]>++++.[-]<++++++++++[>++++++++++<-]>++++++++.[-]<++++++++++[>++++++++++<-]>.[-]<+++[>++++++++++<-]>+++.

I wrote a variant of Brainfuck that isn't just read left-to-right, that's boring. I stripped [ and ], added a single conditional operator ?, and mashed in the directional controls of Befunge.

v < ^ > all change the direction the program reads to the direction they point. ? is the special one, it changes the direction to ^ if the current cell is 0, or v if the current cell is non-zero.

If you wanted to write a "cat" implementation in Brainfuck, it would normally look flat and soulless, like this: ,+[-.,+]. To write the same code in Directional Brainfuck, you get to control the directional flow manually to achieve loops:

v >     e
>,?>-.,+?
  >^    <

Hello world, translated directly from Brainfuck, looks like this:

v         >                                                 >v
                  >                    >v          >   >v                                                      
>++++++++ ?>}++++ ?>}++}+++}+++}+{{{{- ?>}+}+}-}}+ ?>{ ?>{- ?>}}.}---.+++++++..+++.}}.{-.{.+++.------.--------.v
                  >^                   <           >^  <                                                      
          >^                                                <                                                 
v                                                                                                              <

v                     >v                      >v
>}}}}+++>}++++++++++{-?>}+++.}++>{----------}-?>{---.
        ^             <         ^             <

But that's just a 1-to-1 translation, it doesn't have to look like that. Because the 2D plane is actually utilized, whitespace becomes part of the structure.

For example, this program prints "um hewwo!":

v                      >  v
>+++++++++>}++++++++++{?  
          ^           -<  
v<                        
}?-{{{{{{{+}+}+}+}+}+}+}<}<
+>                      ^
+
+
+
}
+                     >v
>{{++>}}}+++++++++{{{-?>}}}+v
     ^                <     
      v<                    
v+}}}}<?-{{{{+++++}}}}<++{{{<
       >              ^
                         >v
>{{{{+++>}}}}}+++++{{{{{-?>}}}}}++v
        ^                <         
v+++++++++}                       <   >v
>{{{{{{+++>}}}}}}}}++++++++++{{{{{{{{-?>}}}}}}}}++v
          ^                           <            
E<    .+}}}}.}..}.}.{{{{{{{.}}.}.}}}}}} {{{{{{{{{ <

I'm sure you can see how being able to read left to right, right to left, and up and down, is obviously much more powerful and elegant than traditional 1-dimensional Brainfuck.

Anyway. I'd love some feedback from the community. Thoughts?

There are more examples on my github. Here's the repo: https://github.com/imtomt/dbrainfuck

The pictured code is a solution for a programming problem which counts # of prime numbers among given numbers. First one is the code in my own language, and the second one is the compiled BF code which works well (can only handle numbers fit in a cell but you can always use bitwidth conversion).

Caveat: I've been vibe-coding optimizer, compiler, and VSCode language extension for prototyping, but this post is not about vibe-coding. I assure that this post, all the ideas below, and the pictured high-level code are 100% human-devised.

I've been brainstorming a language that compiles to BF, "feels like" using BF, with minimal code overhead, and most importantly supports some forms of variables and function-likes (i.e. macros).

Here are key ideas that did work:

• Concept of "frames" as in stack frame: You define variables relative to "base pointer". Not shown in picture but you can also define layouts (like C struct) and reuse them.
• Tracking pointer movement inside loop ("delta-tracking"): If net pointer movement is zero, frames as defined above can be reused. If not, then frame is "invalidated" inside and after the loop.
• Macro by itself is not novel, but with features below, it becomes quite more powerful.
• -> as an alias for comma inside macro parentheses, to separate input and output parameters: this is purely cosmetic but the code became much more readable.
• Introduction of temporary cells: You pass caller-preserved arguments to macro. You can define temporary cells inside frame layout, which will auto-passed to macros.
• Block parameters: conditionals such as if and while can be implemented using macros. One big problem is managing variable assignments, which can be solved by employing delta-tracking.
• Constant folding optimization (delta-tracking with implicit frame can come handy). Without this macros and assignments will include a lot of unnecessary [-]s.

BTW, if you see the compiled BF code, you'll see that there are a lot of +s and -s. That's intentional. I try to minimize for run time but not code length (so no optimization for setting constants), and I believe that practically all BF interpreters implement run-length encoding optimization.

I'm still not finalized on syntax, and it's currently lacking some major features I think is essential (the biggest one is something like "variable-length array" declaration that would enable "random accessing" (sadly not in O(1), as expected)).

its bad but does work

++++++++++++++++++++++++[>+++<-]>.[<]++++++++++++++++++++[+++++<<-]+.+++++++..+++.<<++++++++[>++++<<<-]>.[<]+++[>+++++<-]>.>.+++.------.[<]+++[>++++<-]>+.>>+.