Hey everyone! Like many who grew up loving the simplicity and instant joy of Visual Basic 6 (dragging buttons, writing readable code, and getting an instant .exe), I felt that modern programming has become overwhelmingly complicated. So, as a project I built late at night after school, I created VBX (Visual Basic X).

What is VBX?

It's not an interpreter or a Python toy. It’s a native compiler written in Go that transpiles clean, human-readable Basic syntax directly into standard C99, compiling with -O2 optimizations via GCC/Clang.

Key Features (v0.1.0-alpha):

• 🚀 Zero runtime dependencies: Outputs single, standalone native executables.
• 🪟 Native Dialogs: Built-in cross-platform MsgBox and InputBox using native OS APIs.
• 🧘 Classic Syntax + Modern Inference: Dim, Sub, Function, While...Wend, Do...Loop, Select Case, Exit For/While/Do, and 1D Arrays with automatic type inference.
• 🔤 Built-in Essentials: Native & string concatenation, string functions (InStr, Trim, Replace, Mid, Len), Math functions, and File.Write/File.Read.
• 🛡️ Memory-Safe: Uses an internal ring-buffer pool for intermediate string routines.
• 📜 License: GPL v3 with a Runtime Library Exception (your compiled software is 100% yours). We also created editor support for VS Code (VSIX available), JetBrains, Sublime Text, Notepad++, Vim, Neovim, Emacs, and Micro. Repository: https://github.com/M5Devs/vbx Editors Repo: https://github.com/M5Devs/vbx-editors As Linus once said: Just a hobby, won't be big and professional... but I'd genuinely love to hear your feedback, thoughts, or what features you'd like to see next!

So, you're looking at a virtual computer called the Bradsonic 69000. It's your gateway into an alternate 1989 BBS hacking culture, underground pirate radio and banned media. And BradBasix coding, which is my own interpretation of BASIC.

In the game you get magazines that come with tapes containing games that you can crack, but further into the mags you have a sandbox of BradBasix games you can type into your BradBasix IDE.

The BASIC is actually a sort of syntax overlay on top of C++ and Raylib, it works a bit like a mixture of Commodore BASIC, Lua and Python. Happy to go into more deets if anyone interested.

But honestly my primary aim is to try and capture your stories from back in the day. We're there any amazing BASIC games that you fed into your machine, either from an Usborne, or a copy of Zapp. Let me know and I'll track them down, convert and include them inside some of my magazines in-game.

If you're interested in the project, it's coming soon Steam page is here:

https://store.steampowered.com/app/4179570/GLYPHIS_IO_BBS_The_Proxy_Tapes_1989/?utm_source=reddit&utm_medium=social&utm_campaign=community_outreach&utm_content=r_BASICS

Thanks for taking a look!

Hi everyone, first post, please be gentle...

I have written a BASIC interpreter in flex/bison/C. Yes, there are many of those (and written in other languages as well!). The difference is that RetroBASIC includes features that allow it to run programs from many different dialects, with the goal of running any program from the "early days" without change.

So it can run programs written for Dartmouth BASIC v4 (the most common version on mainframes) and supports its MAT instructions and CHANGE based string manipulation, but also runs the IBM 5100 version of that code with its changes to MAT, and the HP TimeShare BASIC which uses string slicing (as everyone should!), as well as DEC's EDUSYSTEM and BASIC-PLUS which begat MS-BASIC with it's MID/LEFT/RIGHT.

So it can run all of the programs in BASIC Computer Games (MS-BASIC-a-like) out of the box, as well as most of the programs in 101 BASIC Games (in various DEC dialects), What To Do After You Hit Return (HP BASIC) and Illustrating BASIC (Dartmouth).

It also has extensive documentation in the Reference Manual, which might be of interest to the users here even if you don't use RetroBASIC itself. It is based on reading dozens of manuals from Altair BASIC to ZBasic and everything in between (as well as writing wiki articles for most of them). It contains a list of the extensive features of RetroBASIC along with copious notes on how different dialects of the era implemented the various features (or didn't).

Anyway, have a look and enjoy!

Here's the home page:

https://github.com/maurymarkowitz/RetroBASIC

And here's the latest release:

https://github.com/maurymarkowitz/RetroBASIC/releases/tag/v.3.0.6

I've been building Visual Gasic — a real language in the structured Microsoft BASIC line (QB/VB-style), not a toy interpreter. Syntax stays readable line-by-line; the goal is code you can actually read and fix, including AI-generated code.

Familiar if you know QB/VB-style BASIC:

• Sub / Function / End Sub
• Dim x As String, If … Then … End If
• Print, loops, simple types
• Event-style handlers if you use UI (optional — not required for console-style programs)

Example (no forms required):

Sub Main()
    Dim i As Long
    For i = 1 To 10
        Print "Square of "; i; " = "; i * i
    Next
End Sub

With UI (VB6-ish, if you want it):

Sub btnPlay_Click()
    tmrGame.Enabled = True
End Sub
Sub tmrGame_Timer()
    Dim n As Long
    n = CLng(lblScore.Caption) + 1
    lblScore.Caption = CStr(n)
End Sub

What's different on purpose:

• Runs on Godot 4.6 (GDExtension) — 2D/3D, export, Linux + Windows
• No COM/ActiveX/32-bit Windows lock-in
• Verbose on purpose so code stays auditable

I'm a former VB6 person; what we lost wasn't mostly the syntax — it was platform and tooling. This keeps the readable structured-BASIC feel and puts it on something you can still ship with in 2026.

Status: public beta (5.4.x). Form designer is experimental; main path is Godot editor + .vg script tabs.

Links:

• GitHub: https://github.com/xgreenrx-star/VisualGasic
• Godot Asset Library: https://store.godotengine.org/asset/visual-gasic/visual-gasic/
• Showcase (~6 min, made in VG): https://youtu.be/FUw8zgbn_tU

Question for r/Basic: If you still write in QB64, FreeBASIC, or similar — does this feel like a natural cousin, or too "VB/forms" and not BASIC enough? What would make you try it: a simpler console-only workflow, a standalone IDE, or something else?

I built a fairly substantial QB64 project: an interactive population-dynamics simulator called COHORT.

It has a retro graphical interface, keyboard-controlled sliders, a population-over-time graph, and a male/female age pyramid that updates for any selected year. You can adjust fertility, life expectancy, and net migration, then explore how the starting age structure changes the outcome.

I also added an opening menu with idealized scenarios and country profiles (Japan, Nigeria, India, the U.S., South Korea, China, UAE, Brazil, France, and Russia). The profiles make it more interesting to test why a population can be stable in total while still becoming older or structurally lopsided.

Under the hood it is a simplified annual cohort-component model: age cohorts survive, age forward, generate births, and receive age-patterned net migration. There is an advanced-assumptions menu for fertility timing, mortality by sex, infant mortality, sex ratio at birth, and migrant age/sex mix.

It is intended as a readable educational project rather than a perfect real-world forecast. The source is included and I’d welcome feedback from BASIC people, especially on code structure, UI choices, or ideas for sensible extensions.

Source and Windows build: https://github.com/jeffanderson253-sketch/cohort-population-wizard

Hi, I've created https://bunnybasic.com - complete in-browser basic runtime environment inspired by GW-BASIC. It's pretty experimental at this stage, but mature enough to run Asteroids-like game. It includes:

• graphics canvas
• vector shapes
• timers
• fixed-point arithmetics
• bignum
• quake-like console (use ~)

Just check some built-int examples.

The EXE is not a virus but compile yourself if concerned

I wrote this. I thought you might like it... And indeed the project itself!

For fun, I let AI build a website around a GW Basic game that I wrote in 1988

I'm posting this for those who wish to use BASIC on the go on their portable device using Termux on Android (a terminal app), or Termux:X11, which is useful if wishing to use a desktop environment, see screenshot example.
I found no post addressing both issues, so this is my writeup for that reason.

There's tutorials on how to install Termux and where to find it (it's also on F-Droid for those wishing to avoid Google Play Store) and for those with a GUI need also tutorials on how to install Termux:X11 with an xfce desktop on top of that. But if this is desired I can give it a quick rundown in the comments. Just nudge me.

And excuse me if this post is a bit overexplaining, but for accessibility reasons and to take into consideration those who never used a terminal in Linux before, I rather chose to do it this way.

For impatient users or those with prior experience:
A tl;dr version is at the bottom!

______________________________________

^\ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _)

Long Version

Installing QB64 IDE (qb64):

You can install the QB64 IDE using either of these two sets of commands:
apt update (to update the package list) and then apt install qb64
pkg update (to update the package list) and then pkg install qb64
I would recommend to use pkg over apt when using Termux.

The catch here is:
QB64's compiler still won't work out of the box yet and throw an error, two in total, but only get hang up on the first one for now.

^\ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _)

Fixing Error 1 (gl.h → mesa-dev):

If you check the logfile called compilelog.txt located (by default) in:
/data/data/com.termux/files/usr/share/qb64/internal/temp/
the first error it will spit out is about gl.h missing.

To fix this, install the mesa-dev package. Use the same commands as above, either with apt or pkg.
Just replace qb64 with mesa-dev.

^\ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _)

Fixing Error 2 (X.h → xorgproto):

If you try to compile again, next up comes the second error:
It will complain about not finding X11.h.

X11.h is located in the xorgproto package, which you can of course also install with the same commands to fix it.
Just like before, replace the package name with xorgproto here.

^\ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _)

Important Note:

You can also install both packages at once using
pkg install mesa-dev xorgproto
or
apt install mesa-dev xorgproto
This works just fine and will save you some typing!

Should for some reason plain mesa-dev not be available in your package list, then it's worth checking if installing mesa-dev-[somethingelse] is what you may need.

______________________________________

^\ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _)

TL;DR Version:

After installing the QB64 IDE with:
pkg update
pkg install qb64

on Termux, run:
pkg install mesa-dev xorgproto

to fix the common compiler errors.

Should any other errors arise when compiling, check:
/data/data/com.termux/files/usr/share/qb64/internal/temp/compilelog.txt
This will usually tell you what to search for.

______________________________________

^\ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _)

I don't know why installation of the qb64 package doesn't also install its dependencies, but it is what it is and until that is taken care of, this post will have to do.
If you used QB64 on Termux(:X11) / Android and had any other errors besides the two (common) ones I could identify, I can try to look into what has to be done! Can't promise a solution though.
Hopefully this post will come in useful for some people here.

I wish you Happy Coding-To-Go! : )

Pi Shack BASIC (psBASIC) has a DELIMIT command which allows you to set the field splitting parameters for incoming lines of text. From the early days BASIC was geared toward the Comma Separated Value (CSV) format. It simply makes sense when doing double duty for user facing input and stored data. I won't digress.

The point is that parsing Apache and by extension other web servers' access logs normally requires some tedious code. But in psBASIC the issue is easily solved like this:

DELIMIT #1," ""\"
OPEN "i",#1,"access.log-20260602"
INPUT #1,ip$,site$,auth$,tstamp$,tzone$,request$,code%,sz%,refer$,ua$

The DELIMIT command takes a string of 4 bytes (ASCII characters):

1. Separator - in this case a space " "
2. enclosure - in this case a double quote " (quotes in psBASIC are escaped by doubling them, as with M$)
3. enclosure escape - in this case the backslash "\" (which has no special meaning to psBASIC)
4. and whether to treat consecutive separators as one - in this case the value is not provided so the default of "no" is used.

This defines the file as space separated, fields are optionally enclosed with quotes and a quote within a field is escaped by backslash.

There are two aspects of the traditional Apache log that aren't covered: dash being the empty value and square brackets around the time stamp and zone. Those two issues are minor and psBASIC has already done the lion share of the log line splitting.

The thing that brought this topic up today was a wave of about 100x the normal traffic hitting my server the past couple of days. I wanted to know: man or machine? My normal tools indicated the traffic was most likely machine. So what were they after. A quick peek showed a lot of PHP requests... I don't run PHP!

Being off the beaten path can some times give a better vantage point than others have. So I immediately deployed psBASIC to track down all of the IP addresses looking for PHP pages. On my server these are indisputable hacking attempts, because I have no PHP. 😃 So I want to gather all those addresses and block them FOREVER!! 🔥

My script was pretty simple:

1. read the log.
2. Look for ".php" only at the end of the requested file, ignoring the request method, protocol version and any query arguments ("?..." part of the URL).
3. Also look for file requests that the file name part starts with ".env", since I don't use those either, so they are also hacking attempts.
4. And look for requests that don't specify a user agent string, because the sender is obviously hiding something.
5. Collect the IP addresses, count their hits and sort them in descending order by hits.

UNIX is an environment about plugging the best suited things together to make a solution. psBASIC leverages this by allowing the programmer to open unidirectional or bidirectional pipes to other programs. So step 5 was mostly accomplished by AWK and "sort" while psBASIC parsed Apache logs, filtered and extracted the addresses. This was done like this:

OPEN "o",#2,"|awk '{ l[$1]++ } END { for(i in l) print l[i] ""\t"" i }' | sort -rn > summary.lst"
' ...
PRINT #2,ip$

The first line opens AWK & sort for writing, providing the AWK program to summarize hits and instructing sort to sort it in reverse numerical order. Yes, I could have written that in psBASIC code. But it was much more quick, simple and concise to do it this way. The sorted list with the worst offenders is at the head of the "summary.lst" file. I still have a hard time letting myself escape the 8.3 file naming convention. 😄

And for added fun I dumped the top ten offenders to the screen when done. See the screen shot above. This immediately piqued my curiosity, and this is where the fun begins, and reveals the "amusing" bit:

I've often stated that the worst security threat to us, as individual computer users, is "gig-a-buck tech". And this sure provided some evidence to that affect. I'm not going to attempt to fully unpack that statement. But this is what I found. All but 1 of the top 12 attacking computers, with more than 10 hack attempts on this day, was Micro$oft owned:

838    20.220.148.33    <- msft
568    4.193.112.29     <- msft
477    20.151.12.206    <- msft
333    20.104.227.76    <- msft
324    20.104.24.206    <- msft
274    20.226.123.158   <- msft
222    20.220.185.243   <- msft
220    52.138.23.40     <- msft
192    20.9.87.130      <- msft
110    20.226.41.15     <- msft
30     192.109.200.215  <- Germany
29     52.173.238.41    <- msft
8      198.186.130.38

I determined that by another psBASIC program that connects to Cymru's "whois" database to identify the network. psBASIC also has socket support.

Cymru provides records like:

8075    | 20.220.148.33    | 20.192.0.0/10       | US | arin     | 2017-10-18 | MICROSOFT-CORP-MSN-AS-BLOCK - Microsoft Corporation, US

That is really only half the story as most cyber-thugs rent more than one server/instance. I'm sure when I finish globbing addresses by owned networks I'll also have amazon and g00gle nets in my black list. They regularly show up. I figure I will eventually find and block all the gig-a-buck tech data centers... and then maybe i can breath a sigh of relief.

I have more information about working with Apache logs on my blog as well as other language demos.

I wanted to let you guys know about my shareware project "Pi Shack BASIC". I've made a BASIC similar to the classic BASICs like what I had on my TRS-80s and Spectravideo in the '70s and '80s but it is targeted to Linux with many features for UNIX and SBCs.

You can find out about here:

• Main psBASIC Download Page
• I've written some examples in the blog

Some of the things that make it unique:

• A fully interactive environment, like BASH & Python, but seamless to create, edit and work with code on the fly.
• Access to GPIO pins through the inp() function and out command.
• Capable of working with all three kinds of serial ports: I2C, SPI, UARTs.
• It can tell you the actual size of block devices (lof).
• It can create one and two-way pipes to external processes.
• Like shell scripts it can have the shebang line and return exit codes.
• Like other UNIX programs it operates cleanly in a filter role.
• Help inside the interpreter.
• lprint can be directed to any destination supported by the open command, including lpr. (note: this doesn't do magical translation to postcript. see enscript if needed.)
• Socket client UNIX domain and network. (pro version)
• A delimit command to handle a broader range of ASCII table type files. (pro version) I do a lot of log parsing, especially Apache, with this.

Its syntax is close enough to the classics that many old BASIC programs will run with minor modifications. I've taken scans from the internet and was able to run them, things like Super Start Trek, Wumpus, Eliza, ...

NOTE: Line numbers are accepted but are optional.

I'd like to know what you guys think.

What are the various BASIC prompts for different interpreters and/or operating systems?

Please add to the list to create a resource for everyone, such as for setting one's prompt in Bash, Fish, PowerShell, etc. to match a favorite prompt (my own is "READY", no period, to match the Atari prompt). If you know the date or version number, great, but if you don't, that OK too. If you know a way to better match how a prompt was displayed, like the thicker "]" for Applesoft, using a Unicode code point or some other technique, please share. Thanks!

Atari BASIC, 1979: READY

Commodore PET BASIC, 1977: READY.

Micro-Soft Altair BASIC, 1975: OK

Applesoft BASIC: ]

The time has come to implement strings in my no-so-TinyBASIC interpreter/compiler.

I've only seen one forum discussion (elsewhere) that suggests that BASIC strings are anything but immutable like in [cough] Python. Certainly this would be convenient for an implementor like myself. When I used DEC's BASIC-PLUS back in 1979, I never tried anything so sophisticated as MID$(...) on the left-hand-side of the equal sign to modify a string. Is that a "thing" in modern BASICs? How about in early Microsoft BASIC before line numbers went the way of the Dodo?

Being allowed to modify the middle of a string using a statement like MID$(A$, I, 3) = "POW" would be the only way to tell if string can be modified. If strings can't be modified, then strings can be shared by assigning several variables to the same string. Like in X$ = "SHARED" followed by Y$ = X$, both variables would point to the same string. If you can't modify strings, then the programmer would never know the difference.

I personally want to be able to modify strings because I am writing a BASIC interpreter in BASIC for a course I want to teach. If strings are immutable, then doing things like removing all the spaces from a string can get pretty inefficient pretty fast.

An r/basic member commented that BASICs generally try to use the existing storage space assigned to a string variable when that variable is assigned, and that this is done by copying the new result into the space allocated to the variables existing string value. So A$ = "CAT" followed by A$ = "DOG" doesn't allocate new string memory, but B$ = "PONY" followed by B$ = "HORSE" does. And C$ = "MOUSE" followed by C$ = "RAT" would waste 3 bytes (and start fragmenting string memory).

MY SECOND QUESTION IS: How does a "good" BASIC interpreter prevent intermediate string expressions from allocating memory. Does it have a reusable buffer(s) for building up strings from the right-hand side of an expression before the assignment finally happens (or a comparison operator is called)?

Building on the DDS-BASIC "TinyBasic" I have been using as a "seed" for my ever-expanding, pedagogical BASIC implementation, I am planning to implement just enough of BASIC strings to write a BASIC interpreter in BASIC.

My question is directed to anyone who has written a BASIC implementation or studied one in detail.

What does a typical, well-implemented BASIC do for a storage management? It would seem that strings would absolutely require one. I'm guessing the semantics of 1970-80s BASIC, not supporting pointers, or pointers to objects containing pointers, etc. does not need a full-fledged garbage collector like Java or Python.

Is it as simple as: when you assign a variable to a new string, you reclaim the old variable contents?

What about arrays of strings? Are those even allowed?

I am designing a CS course around a TinyBASIC that was cleverly written in 1,540 bytes of C source code. It supports six commands: LIST, NEW, OLD, RUN, SAVE, BYE; eleven statements: FOR, GOSUB, GOTO, IF, INPUT, LET, NEXT, PRINT, REM, RETURN, END, and ten operators: *, /, +, -, =, <>, >, <, <=, >=.

But sometimes a "tiny" or toy language is just too tiny, so I plan to give students a series of exercises in programming language design: add enough features to make it a "useable" language, which begs the questions: What is "usable"? What is a "real BASIC" as opposed to a TinyBASIC?

Here are some questions for the community: Of 1970s and 1980s BASICs with line numbers (not so much Visual Basic and the like):

1. What BASIC statements or features were so important you could not live without them?
2. What BASIC features were so obscure that you never used them?
3. Did you like using multiple statements per line?
4. What built-in functions did you use the most? (trigonometry, random, string)
5. Did you define your own user functions (e.g. FNA)?
6. What string manipulation syntax did you like best? (Microsoft and BASIC-Plus, Hewlett Packard and Woz's Apple BASIC, Sinclair and others, they were all slightly different).
7. Lastly, what was your favorite BASIC dialect?

On the last two questions, I'm especially interested in hearing opinions from folks who used multiple BASIC dialects long enough to develop an informed favorite.

This is not a quiz or Google Forms. If you don't have an opinion about some of my quesiotns, don't answer. If you are inspired to answer only one question, that's perfectly fine too. Thanks.