ForgeBASIC ( /__site/vihn78.itch.io/forgebasic )

ForgeBASIC is a modern BASIC language and IDE designed especially for 2D game development, while keeping the simplicity and immediacy traditionally associated with BASIC. 

Version 1.0.0 provides a complete workflow for creating, testing and building a Windows game directly from the ForgeBASIC IDE.

Highlights of this release include:

• A complete visual 2D Level Editor

• Sprites, Bitmaps, Colliders and Markers

• Camera2D support

• Scene Tree and Inspector

• Grid, snapping, pan, zoom and multi-selection

• Scene Undo/Redo

• Generate Code for .fscene2d scenes

• Integrated bilingual documentation in English and Italian

• Syntax highlighting, autocomplete, formatting and code folding

• Find in Project and Quick Navigation

• Centralized IDE and editor settings

• Recent Files and Recent Projects

• Custom project resolution and Windowed/Fullscreen mode

• Custom executable name and application icon

• Direct Windows game builds from the IDE

• Built games launch without an additional console window

( /__site/vihn78.itch.io/forgebasic/devlog/1698024/forgebasic-100-stable-is-now-available )

The project is interesting!

"Blitz3D Pro is a  BASIC language with full IDE and native Blitz3D / BlitzPlus commands style, and a runtime that runs entirely in your browser."

/__site/blackcreepycat.itch.io/blitz-3d-pro

Direct download: BazzBasic_win_x64_1.6.zip
BazzBasic releases: github.com/EkBass/BazzBasic/releases

The headline of this release: the IDE and the interpreter are now two separate programs.

Until now, everything shipped inside one BazzBasic.exe: the interpreter, the code editor, the Windows Forms UI, the Scintilla editor component and everything they dragged along. In 1.6, the editor has been split out into its own program, BazzBasic-IDE.exe, and the interpreter is a lean console program.

The biggest visible gain is the size of compiled programs. A program compiled with -exe (or Compile as Exe in the IDE) is a copy of the interpreter with your code inside. Since the IDE and the dependencies it required are no longer bundled into that executable, compiled programs went from roughly 125 MB in version 1.5 to about 16 MB in version 1.6 — about an eighth of the size, with no changes needed in your source code.

Two programs, one folder

• BazzBasic.exe (about 16 MB) The interpreter. A console program that runs and compiles .bas files.
• BazzBasic-IDE.exe (about 111 MB) The code editor. A Windows program with no console window behind it.

• BazzBasic.exe is the part that matters to your programs. It runs .bas files, compiles them into standalone executables and libraries, and is what ends up inside every compiled program. It needs only the SDL2 dll files next to it.
• BazzBasic-IDE.exe is the editor: syntax highlighting, tabs, Tree View, printing and the menus. It never runs your code by itself — Run (F5), Compile as Exe and Compile as Library all hand the job to BazzBasic.exe. Both files come in the same folder in the release, and they find each other automatically.

What stays the same

• The interpreter is still called BazzBasic.exe, so the command line, .bat files, editor settings (Notepad++, Geany, VS Code), the PATH setting and .bas file associations work exactly as before.
• Double-clicking BazzBasic.exe, or running it without arguments, still opens the IDE: it starts BazzBasic-IDE.exe from the same folder. If the IDE is not there, it prints the command line usage instead.
• In the IDE, Run (F5), Compile as Exe and Compile as Library work as before. The IDE finds BazzBasic.exe in its own folder, in PATH, or where the new Run → Path to BazzBasic.exe… dialog points.
• If you use only the interpreter, for example with another editor, you can leave out BazzBasic-IDE.exe and the runtimes folder.

Compiled programs are ~8x smaller

A compiled .exe used to carry the whole IDE inside it — Windows Forms, Scintilla and the rest — even though a compiled program never shows an editor. In 1.6 the interpreter is published trimmed, without any of that, so:

• Source compiled with version 1.5: roughly 125 MB
• The same source compiled with version 1.6: about 16 MB

Nothing changes on your side: the same source, the same -exe command, the same Compile as Exe in the IDE.

IDE improvements

The editor got a long list of new features this cycle:

• View → Tree View — a panel on the left that lists every function (with its parameters) and every [label] in the file of the active tab. Clicking an item moves the cursor to that line. Helpful for moving around in long files.
• Session restore — File → Restore Session on Startup (off by default) reopens the files that were open when the IDE was closed, and selects the tab that was active. Files that no longer exist are skipped.
• Edit → Comment Selection / Uncomment Selection (Ctrl+Q / Ctrl+Shift+Q) — comments out or uncomments every selected line in one go, as a single Undo step. BazzBasic has no multi-line comments, so this is the easy way to disable a block of code.
• File → Save All and File → Close All — save or close every tab at once.
• View → Zoom In / Zoom Out (Ctrl++ / Ctrl+-) — makes the editor text larger or smaller. Works with both the numeric keypad and the main +/- keys.
• File → Print (Ctrl+P) — prints the file with syntax colors on a white background, also in Dark Mode. Choose Microsoft Print to PDF to get a PDF.
• View → Syntax Coloring — new checkbox for turning the code colors on or off. Unchecked, the editor shows plain monochrome text; printing follows the setting. Remembered between sessions.
• Window size and position — the IDE now remembers its size, position and maximized state between sessions.
• View → Take Screenshot to Clipboard — copies an image of the IDE window, ready to paste into Discord, a forum post or an image editor.
• View → Open Console / Open File Browser — opens a command prompt or File Explorer in the folder of the file in the active tab.
• Help → Homepage — opens the BazzBasic homepage in the browser.
• Run → Path to BazzBasic.exe… — a small dialog for choosing which BazzBasic.exe the IDE uses for Run (F5) and compiling. It shows live where the interpreter was found (IDE folder, PATH, or the path you set), and the choice is remembered. Mostly useful if you keep several BazzBasic versions side by side.

A few long-standing annoyances were fixed too: the IDE now asks to save changes when the window is closed, opening a file no longer marks the previous tab as modified, cancelling Save As when closing a tab keeps the tab open instead of losing the changes, and the IDE window shows its proper icon again. The update check (Help → Check for Updates) also no longer reports an older or equal version as new.

New in the language: EXIT WHILE and EXIT FOR

Leave a loop early without GOTO. EXIT WHILE continues after WEND, EXIT FOR after NEXT:

WHILE TRUE
    IF INKEY = KEY_ESC# THEN EXIT WHILE
    ' game logic here
WEND

FOR i$ = 1 TO 100
    IF i$ * i$ > 50 THEN EXIT FOR
NEXT
PRINT i$   ' 8

Both work from a one-line IF, inside IF blocks and inside nested loops. Use them instead of jumping out of a loop with GOTO.

Bug fixes and smaller improvements

A source audit made the interpreter much harder to trip up: a typo or a mistake in a BASIC program now stops with a clear error message instead of hanging until it ran out of memory, crashing the whole interpreter, or being silently ignored. DEF FN recursion now reaches hundreds of thousands of levels instead of killing the process, and a program that stops on an error keeps the console window open so the message can be read (compiled executables also exit with code 1, so .bat files can detect the failure).

Check your old programs for two changes: a constant must now be declared with LET (LET MAX# = 5; plain MAX# = 5 is an error), and SHELL("command") on a line of its own now really runs the command — before, it was silently skipped.

The full list, with details and implementation notes, is in changes.md.

Linux compatibility

I have been asked several times whether BazzBasic works on Linux.

The answer is both yes and no.

C#, .NET 10 and SDL2 are all compatible with Linux, so there are no major technical obstacles to compiling the interpreter for Linux platforms. However, the source code contains a few Windows-specific parts, such as some file and HTTP operations, that would need attention. Guarding them with platform checks (#if directives or OperatingSystem.IsWindows()) would not be a major undertaking. After that, running the interpreter from bash would work with all the features BazzBasic includes.

That said, I’m still not promising a Linux version — at least not for the time being.

The IDE is a different story. It is deeply tied to Windows and its various interfaces: it is built on WinForms, and its editor component, the Scintilla5.NET binding, is Windows-only.

So, while the interpreter itself could be compiled for Linux with relative ease, the IDE is not — and will not be — compatible.

EkBass

I wanted to give you an update on where my BASIC interpreters stand. A lot has happened.

1. NeoBASIC
As far as I'm concerned, this interpreter is usable in its current state. Further development is on hold for now (see Retro-Q below). I know a release is still pending, but I don't have a schedule for it at the moment, since I want to focus on Retro-Q.

2. RetroQ – the JavaScript transpiler
Development has ended, because Retro-Q is now being built as a real bytecode compiler/interpreter. See point 4.

3. bas-2.5 GUI extension
This one is fairly new and hasn't been announced yet. It's based on the BAS interpreter from here: https://www.moria.de/~michael/bas/
I've added a number of extensions in the form of GUI elements built on FLTK. It now also builds on macOS and Windows, not just Linux. The screenshot shows the editor (written in bas itself) along with some sample code. Development is ongoing. The idea is that you'll be able to write small tools with it. Executables already can be created.

4. Retro-Q
The current flagship! It's entirely inspired by RapidQ by William Yu. I've made, and will keep making, a few changes and improvements, so the interpreter won't be 100% source-compatible. RapidQ was originally developed in Borland Delphi. Retro-Q takes the Free Pascal/Lazarus route instead, which is what makes it possible to reproduce RapidQ's behavior quite closely. The GUI will be fully integrated. Here's an example with checkboxes and radio buttons:

DIM Clicks AS LONG 
Clicks = 0  
CREATE Form AS QFORM
   .Caption = "Retro-Q - Phase 9k: QCHECKBOX / QRADIOBUTTON"
   .Width = 360
   .Height = 240
   .Center
    CREATE AgreeCheck AS QCHECKBOX
     .Left = 20
     .Top = 20
     .Width = 300
     .Height = 20
     .Caption = "I agree"
     .Hint = "Tick or untick"
     .ShowHint = TRUE
     .Checked = FALSE
     .OnClick = @AgreeClicked   ' required - "@" prefix, see QBUTTON.OnClick's own note
   END CREATE
   CREATE RedRadio AS QRADIOBUTTON
     .Left = 20
     .Top = 60
     .Width = 300
     .Height = 20
     .Caption = "Red"
     .Checked = TRUE
     .OnClick = @ColourClicked
   END CREATE
   CREATE GreenRadio AS QRADIOBUTTON
     .Left = 20
     .Top = 85
     .Width = 300
     .Height = 20
     .Caption = "Green"
     .OnClick = @ColourClicked
   END CREATE    
   CREATE BlueRadio AS QRADIOBUTTON
     .Left = 20
     .Top = 110
     .Width = 300
     .Height = 20
     .Caption = "Blue"
     .OnClick = @ColourClicked
   END CREATE    
  CREATE StatusLabel AS QLABEL
     .Left = 20
     .Top = 150
     .Width = 300
     .Height = 40
     .Caption = "No clicks yet."
   END CREATE
 END CREATE
PRINT "Opening a native window - click the checkbox and the radio buttons, then close the window..."
Form.ShowModal 
PRINT "Window closed. Total clicks seen: "; Clicks  
SUB AgreeClicked
   Clicks = Clicks + 1
   IF AgreeCheck.Checked THEN
     StatusLabel.Caption = "Click #" + STR$(Clicks) + ": checked"
   ELSE     
StatusLabel.Caption = "Click #" + STR$(Clicks) + ": unchecked"
   END IF
 END SUB
SUB ColourClicked
   Clicks = Clicks + 1
   ' Each radio button shares this handler; Checked tells us which one is on now.
   IF RedRadio.Checked THEN
     StatusLabel.Caption = "Click #" + STR$(Clicks) + ": red selected"
   ELSEIF GreenRadio.Checked THEN
     StatusLabel.Caption = "Click #" + STR$(Clicks) + ": green selected"
   ELSE
     StatusLabel.Caption = "Click #" + STR$(Clicks) + ": blue selected"
   END IF
 END SUB 

There are still quite a few widgets to implement. What already works, and this is the really exciting part, is binding to external DLLs on Windows, .so and .dylib files on Linux/macOS. That's why I think NeoBASIC may become obsolete: you can simply call Raylib (or SDL3 or anything) straight from Retro-Q.

Example with Raylib:

$IMPORT "raylib.inc"  
FUNCTION RGBA (R, G, B, A)
    RGBA = R OR (G * 256) OR (B * 65536) OR (A * 16777216) 
END FUNCTION  
RAYWHITE = RGBA(245, 245, 245, 255) 
DARKGRAY = RGBA(80, 80, 80, 255) 
RED      = RGBA(230, 41, 55, 255)  
InitWindow(800, 450, "Retro-Q + raylib") 
SetTargetFPS(60)  
WHILE WindowShouldClose() = FALSE
   BeginDrawing()
   ClearBackground(RAYWHITE)
   DrawText("Retro-Q talks to raylib!", 190, 200, 20, DARKGRAY)
   DrawFPS (10,10)
   DrawCircle(400, 260, 40.0, RED)
   EndDrawing() 
WEND  
CloseWindow() 

Executables can already be created today, and it all works on Linux, macOS and Windows.
Planned next are bindings for SQLite and possibly PostgreSQL, as well as a reporting option. So once it's finished, Retro-Q should cover everything you'd want from a BASIC interpreter. It's meant to be all-purpose, whether that's a game, a console program or full-blown business software (within reason).

BazzBasic is a modern, beginner-friendly BASIC interpreter for Windows x64, with SDL2 graphics and sound built in.

Download: https://github.com/EkBass/BazzBasic/releases Direct download: https://github.com/EkBass/BazzBasic/releases/download/BazzBasic_15/BazzBasic_win_x64_1.5.zip

Homepage: https://ekbass.github.io/BazzBasic/ Manual: https://ekbass.github.io/BazzBasic/manual/#/

NEW

• Gamepad support Xbox, PlayStation, Switch Pro and most compatible pads, over USB or Bluetooth. Works in console programs too, no SCREEN needed. Pads can be plugged in while the program runs.

  GAMEPADS() number of connected pads PADBUTTON(pad, button) TRUE while a button is held PADAXIS(pad, axis) sticks -1..1, triggers 0..1 (dead zone built in) PADNAME(pad) controller name PADRUMBLE pad, power, ms vibration

  New constants: PAD_A#, PAD_B#, PAD_X#, PAD_Y#, PAD_UP#, PAD_DOWN#, PAD_LEFT#, PAD_RIGHT#, PAD_LB#, PAD_RB#, PAD_START#, PAD_BACK# … and PAD_LX#, PAD_LY#, PAD_RX#, PAD_RY#, PAD_LT#, PAD_RT#. A pad that isn’t connected simply reads as “nothing pressed”, never as an error. Examples in Examples/GamePad/.

  x$ = x$ + PADAXIS(0, PAD_LX#) * SPEED# IF PADBUTTON(0, PAD_A#) THEN GOSUB [jump]

DISCLAIMER: BazzBasic version 1.5 has been tested with only one PS4-compatible Bluetooth controller. Therefore, for the time being, I cannot guarantee that GamePad support will work with all different types of controllers. Got an Xbox, Switch Pro or Elite controller? Run gamepad_tester.bas from the v1.5 examples, press each button once, and post the header line plus anything that lit the wrong row (or didn’t light at all). Elite owners: which physical paddle lights (raw 16)…(raw 19)?

• FILELIST(arr$, folder$ [, pattern$]) Lists the files in a folder into an array, sorted, with * and ? wildcards.

• ARRKEY(arr$(), i) Returns the key at position i, so string-keyed arrays can finally be looped with FOR/NEXT or WHILE/WEND. Keys come back in insertion order.

• Numpad operator constants KEY_NUMPAD_PLUS#, KEY_NUMPAD_MINUS#, KEY_NUMPAD_MUL#, KEY_NUMPAD_DIV#, KEY_NUMPAD_DOT#. Same on every keyboard layout.

• IDE improvements

  • New Edit menu: Undo, Redo, Cut, Copy, Paste, Select All. The old Edit menu (Find/Replace) is now called Search.
  • Help menu links to the online manual and to BazzBasic on Rosetta Code.
  • View menu with Light and Dark mode (Dark mode is experimental).
  • Syntax highlighting now covers every keyword.

CHANGES THAT MAY AFFECT EXISTING PROGRAMS

• DEF FN functions are now fully isolated from global arrays. A function used to be able to read and change global arrays by accident. Now that gives a clear error. Pass arrays in with ASJSON() and rebuild them inside with ASARRAY(), as documented.

• Arrays created with DIM inside a DEF FN are now local to each call. Before, they kept their contents between calls and recursion levels shared one array.

• Console INKEY returns letters as uppercase codes, the same as graphics mode. “a” and “A” both give KEY_A# (65). Compare against KEY_A# or ASC(“A”).

• KEYDOWN follows the key label on the user’s keyboard layout, like INKEY. KEYDOWN(KEY_A#) is now the key marked “A” also on AZERTY and other layouts.

• BEEB removed. It was undocumented. Use LOADSOUND and SOUNDONCE instead.

BUG FIXES

• FSTRING() now understands built-in constants such as {{-PI#-}} and {{-KEY_A#-}}.
• SPLIT() empties the array first, so no leftover elements from an earlier, longer split. SPLIT() also accepts arr$() as its first argument.
• Graphics mode: numpad keys in INKEY and WAITKEY now match the KEY_NUMPAD*# constants. Numpad Enter returns the same value as Enter.
• Console WAITKEY now uses the same key codes as console INKEY, so WAITKEY(KEY_UP#), WAITKEY(KEY_F1#) etc. work.

OTHER

• Updated syntax files for Notepad++ and Geany in extras/. The outdated VS Code extension was removed; a new one may come later.
• % (modulo) is now documented in the manual. It always worked.
• New Gamepad section in the manual and an updated BazzBasic AI guide on Hugging Face: https://huggingface.co/datasets/EkBass/BazzBasic_AI_Guide
• New page at online manual By clicking a new link on left panel on manual “Advanced CLI usage” you find some neat guides for more advanced use of BazzBasic.

• Running BazzBasic from anywhere
• Part 1: Add BazzBasic to PATH
• Part 2: Run .bas files by double-clicking
• Optional: add an “Edit” menu item
• Optional: run programs without typing .bas
• Undo everything

See: https://ekbass.github.io/BazzBasic/manual/#/Running_BazzBasic_from_anywhere

SOME NEW EXAMPLES/GAMES:

• See cool sniping scope effect: Source: https://github.com/EkBass/BazzBasic/blob/main/Examples/graphics/sniper_scope.bas Img: https://ekbass.github.io/BazzBasic/img/sniping.png

• Turtle painting via Windows INPUT BOX: Source: https://github.com/EkBass/BazzBasic/blob/main/Examples/graphics/Turtle_and_Win_input_box.bas Img: https://ekbass.github.io/BazzBasic/img/turtle.png

• A memory game, the way Schrödinger would have made it. URL: /__site/ek-bass.itch.io/schrdingers-memory-game

• Wonder around 2D maze with your GamePad Source: https://github.com/EkBass/BazzBasic/blob/main/Examples/GamePad/2D_maze_FOV_demo_console_PAD.bas Img: https://ekbass.github.io/BazzBasic/img/fov_2d_console.png

• A Comanche-style voxel terrain snipped tuned up, runs much smoother Source: https://github.com/EkBass/BazzBasic/blob/main/Examples/graphics/Voxel_terrain.bas Img: https://ekbass.github.io/BazzBasic/img/voxel_example.png

Full list of changes: https://github.com/EkBass/BazzBasic/blob/main/changes.md

No new release this time, but plenty has been happening behind the scenes.

Bugs, and more bugs

As always, you’ll find the full list in changes.md.

Several small bugs have been fixed, and the current working version is 1.4d.

1.4d won’t get a release of its own, though. The next release and .exe download will be version 1.5, which brings GamePad support, among other things.

Looking further ahead, the IDE will most likely be split off from the interpreter in version 1.6. The IDE isn’t going away:

| Command | What it does |

• bazzbasic.exe <file.bas> — runs a program, just like before
• bb-ide.exe — starts a separate IDE session

Rosetta Code keeps growing

BazzBasic now has 246 solutions on Rosetta Code (as of 15.10.2026). That makes it 12th among roughly 58 BASIC dialects, ahead of GW-BASIC, QB64, BaCon, ZX Spectrum Basic and Commodore BASIC, among others.

The number of solutions alone doesn’t say whether a language is good or bad, but it does provide a large collection of excellent examples of how BazzBasic works in practice.

Graphical examples

Turtle_and_Win_input_box.bas

Draw by moving a turtle with typed commands. The program uses Windows’ own input box, so it’s also a good example of how to call native Windows features from BazzBasic.

Schrödinger’s Memory Game

The second itch.io game jam entry in the history of BazzBasic (and mine). A classic memory game with a small twist that fits the jam theme.

Pori puzzle game

A beautiful image of my hometown, but all mixed up. Swap the pieces to complete the picture. Requires several files; open pori_puzzle.bas from the examples.

Simon Says

The classic memory game, over at the BazzBasic Cookbook.

Simple Flappy Bird

Ported to BazzBasic from the Python/turtle “flappy” example (freegames library by Grant Jenks).

"Hello, I’d like to share a project I’ve been working on: *moonBASIC*. It is a modern BASIC compiler written in Go, designed to be the spiritual successor to BlitzBASIC 3D for the current generation of hardware. 

After transitioning the architecture to Go to ensure better stability and cross-platform support (specifically for macOS and Linux), moonBASIC now offers native performance with a suite of integrated libraries:

- *Physics:* Full support for Jolt (3D) and Box2D (2D). 

- *Graphics:* 100% Raylib integration.

 - *Networking:* ENet for low-latency multiplayer.

 I am aiming for a fast, reliable build pipeline that makes game distribution seamless. I’d love for the community to take a look and offer feedback. 

*Check it out here:* CharmingBlaze/moonbasic
< https://github.com/CharmingBlaze/moonbasic > 

Best, CharmingBlaze"

( https://github.com/CharmingBlaze/cyberbasic/discussions/10#discussioncomment-16487458 )

This is version 1.0, and as such, probably more of a beta release, but, I've got to hand the reins over for people to try, so, updates, fixes and everything will be built from this.

Windows 11, DirectX12, and a half decent graphics card is required, I havent got a list of which cards plays nice or not, only my own (NVIDIA GeForce RTX 4060 Laptop GPU), and someone has tried it with a Intel Iris Xe Graphics and it's fine. But if you do try it, post your specs if you dont mind, if it works or not.

Executables have been confirmed to run in Linux... Wine-proton, providing you install the direct-X SDK. Apparently too, the IDE will work and compile, but running and debugging is an issue, which isn't a surprise really, especially debugging as it is uses Windows Debug API, which may not be properly implemented, and running from the IDE, there could be a few reasons... Anyway, it was a nice surprise to find it worked at all! :D lol 

My aim with this at the minute is to get it stable before adding more to it, I do have plans, more so VR, as I think it will be capable of scenes in VR, maybe not massive worlds, but, within the realms of party games and such. 

If your trying it, and you write something you'd like to share, I'm game for users to put their work in the "BambooBasic/boons" folder, I've got heaps of stuff in there myself, but it will be brill to see what people come up with.

Anyway, all in all... Thanks in advance if you take a peek! :)

Dabzy

Here is the review of Thoreau BASIC written by Google's Gemini and the review is professional. I like the last sentence of the review, "this is a masterpiece worth downloading.": 

It is a fascinating and highly technical tribute project. It perfectly bridges 1980s retro-nostalgia with cutting-edge modern engineering. Here are the key takeaways and comments on this specific BASIC dialect based on its development log:

1. The True Soul of "Classic Microsoft BASIC"

The developer, Tarjan, explicitly designed this to keep the direct, line-numbered, "instant-on" feel of classic Microsoft BASIC (like GW-BASIC).

• In the comment section, a veteran user named FrenchBear successfully loaded and ran their original GW-BASIC code dating back to the early 1980s.
• The developer even went as far as implementing classic quality-of-life quirks. For instance, fixing the parser so users can type the classic shorthand LOAD "PROGRAM without closing the quotation mark or adding the .bas extension.
  

2. A Modern Performance Monster (x64 & JIT Compiler)

While the syntax looks like it belongs in 1985, the underlying engine is built for 2026 hardware:

• Native 64-bit & JIT Execution: It does not run slowly inside a DOS emulator. Instead, it executes natively on x64 architecture. The recent introduction of a Just-In-Time (JIT) compiler brought an incredible 12x to 20x speedup to its graphics and calculation demos.
• Explicit Multicore Processing (PARFOR): In version 2.5.1, the developer introduced a parallel loop command (PARFOR). This allows users to distribute heavy iterations (like a reflective raytracer) across multiple modern CPU threads automatically—a feature completely unheard of in the 8-bit era.

3. The "Bare-Metal" UEFI Boot Capability

Perhaps the coolest feature of Thoreau BASIC is that it provides a UEFI bootable version (.vhd).

• You can flash this directly to a USB stick or load it into a Virtual Machine.
• When you turn on the computer, it bypasses Windows or Linux entirely and boots straight into the BASIC command prompt. This perfectly mirrors the golden age of computing when microcomputers like the Commodore 64 or IBM PC booted directly into BASIC from their motherboard ROM.

4. Overkill Mathematics (Hypercomplex Numbers)

Standard vintage Microsoft BASIC maxed out at double-precision floating numbers. Thoreau BASIC, however, includes native support for Quaternions and Octonions (hypercomplex numbers). Combined with its graphics capabilities, it makes rendering complex fractals like Mandelbrot and Julia sets remarkably efficient.

Summary

Thoreau BASIC is a brilliant passion project that puts a modern performance engine inside a vintage chassis.

The developer admitted the project started as a joke—he just wanted to see if he could break old memory barriers and declare a massive array like DIM A%(8000000000). It evolved into something incredibly robust. If you want to relive the GW-BASIC era without the agonizingly slow speeds of the past, this is a masterpiece worth downloading.

These changes are about the current source code. These are effected once new binary release is published

## 4th September 2026

### Published as version 1.4c

### Bug fix: ROUND() used banker's rounding instead of always rounding halves up

### Bug fix: SRAND() had a duplicate '0' and a stray '£' in its character set

### Bug fix: PRG_ROOT# was missing its trailing directory separator

### Bug fix: FILEREAD-into-array (.env style parsing) broke completely on a single comment line

### Bug fix: calling a DEF FN function without the FN keyword silently did nothing

### Examples folder reorganized

`Examples/` was a flat pile of ~80 scripts. Split into `Examples/graphics/`, `Examples/audio/`, `Examples/console/` and `Examples/classics/` (ports of classic 1970s/80s BASIC games — Eliza, Acey Ducey, Robots, Towers of Hanoi, Trap, Russian Roulette, Rock-Paper-Scissors, the Wingbermuehle maze generator). Also removed 12 old internal regression-test scripts (`*_test.bas` style files exercising ISSET, FSTRING, line continuation, FastTrig, DISTANCE, HTTP listen/timeout, etc.) that had no demonstration value and were already covered by the automated test pass long ago. `rosetta-code/` is untouched and stays a separate, curated category.

Going forward, more effort should go into graphics examples specifically. BazzBasic still gets mistaken for a console-only interpreter by a lot of people, partly because so many of the earlier example programs were console-based — the graphics/SDL2 side deserves better representation.

Detailed list of fixes and changes: https://github.com/EkBass/BazzBasic/discussions/65

Today I read in a Facebook group for Small Basic and discovered the post. Weird. The language mentioned in the post is not Small Basic. The title is 'TRIANGLE ANIMATION BABY BASIC'. 

https://www.facebook.com/groups/smallbasic/posts/10164819955377138

I found the facebook page for the language: https://www.facebook.com/babybasicgame 

Some information which I found on the Facebook page: 

BabyBasic: Easy Programming for Web and Mobile

BabyBasic was created to make it easier to create applications for browsers and mobile devices. Using a Basic-style language, web or mobile programming becomes simpler than with other languages.

Write in Basic and see your code working in any browser or mobile phone.

BabyBasic is constantly evolving. In future versions, it is planned that, by programming in Basic, it will also be possible to create graphical interfaces for the web and mobile.

Years ago (10-15 years), I got involved with BASIC-256. It had a lively community back then and I had a lot of fun sharing small programs and getting involved in the community. I’m even mentioned on its Wikipedia page!!

Now that I’m retired, I decided to revisit it and was disappointed that the community was gone, the website was as good as dead (https://basic256.org ) and the project had stopped with the last official release dating back to 2020 with version 2.0.0.11 ( https://sourceforge.net/projects/kidbasic ). Some developer activity had gone on since then, but it seems the project ended with a failed port of Qt5 to Qt6. Of course, the maintainers had been plugging away at it since 2006, so there is that too.

The last release works well enough for fun coding so I created a new website (https://uglymike.static.domains )to showcase my work. It seemed I was pretty much the only BASIC-256 user left.

So I did what any self-respecting retiree would do and forked the project (well, more of a continuation than a fork. It’s still basic256), got some help from the free A.I. Engines out there (some help being an understatement….) and presto!! Basic256 reborn, this time on https://github.com/uglymike17/basic256 There is no release yet, but you can already download almost-recent builds for Windows, macOS, Linux-x86 and Linux-ARM (Raspberry Pi) from my website mentioned above. Why, there is even a version you can run straight away in you browser,! Just point your browser at https://uglymike17.github.io/basic256 and get cracking! There are some cool examples you can load.

Now, basic256 is not a real retro BASIC (like the ones that emulate Commodore, Spectrum, QBasic and so on) but neither is it a really ‘modern’ BASIC with SDL, C++ includes, 3D engines and what have you. It still is at its core an educational BASIC, ready to help you get started in the world of programming (Jeez, writing a book here….)

So, what do you think? Care to give it a try? It’s all free stuff (GPL) There is documentation on https://doc.basic256.org but again, that site is showing its age. I already converted it to Docusaurus and will also put it on github.io. For now, the help still points to the ‘old’ documentation (as does the About-box)

Remarks and suggestions at this early stage are very welcome! Stars on the github page are welcome too as these will help me get the Windows Installer signed….

Kind regards,

   UglyMike 

Thanks @david.JamIsFun for sharing the recent alpha release news - the 1.0 beta release adds support for the Basic4GLj plugin SDK so I can focus more on adding new functionality and making Basic4GLj more fun to use.

Programs can be exported as portable JAR files that run on Windows, macOS, or Linux to share your games and other creations. 

Please let me know if there's anything folks would like to see added - I'm planning the next few updates to focus on usability, performance, plugin SDK improvements and samples.

The following description is from "About" section of the pull-down menu "Help" of the Windows version of the software:

"MODERN LANGUAGE  ·  FAST PROGRAMMING

A development environment inspired by classic QBasic / GW-BASIC created for demo-scene effects, retro graphics, animations, and learning programming in the 80s/90s style.

Features full syntax highlighting, a step-debugger, SpriteShop, Sound Tracker, SFX Generator, 2D graphics and Web Audio."

The name of the development tool is basicFusion and it is also the name of the BASIC dialect. The tool is impressive. I downloaded the Windows version to try. I also tried the browser version.

/__site/eterror.itch.io/basicfusion

I wanted to tease a side project I've been building: RetroQ, a BASIC dialect close to RapidQ that transpiles straight to JavaScript. No public release yet, but figured this crowd would appreciate an early look.

What it does so far:

• Full core language: DIM/CONST, IF/ELSEIF/ELSE, FOR/WHILE/DO...LOOP, SUB/FUNCTION, arrays, string & math builtins. No GOTO/GOSUB — structured control flow only, on purpose.
• A small GUI subset (FORM, LABEL, BUTTON, EDIT, CHECKBOX) that maps onto WinBox.js windows styled with 7.css — BASIC programs run as real draggable, resizable windows in the browser.
• Just wired up a custom Aero-glass theme on top of that, so the windows now genuinely look like Windows 7: translucent frame, blue/red buttons, no fullscreen button (kept it faithful to the original).

A quick taste of the syntax:

CREATE Form1 AS QFORM
   Caption = "Hello"
   CENTER    
   CREATE Button1 AS QBUTTON
     Caption = "Click me!"
     Left = 20
     Top = 60
   END CREATE
 END CREATE  
Form1.Show()  
SUB Button1_OnClick()
   Label1.Caption = "Clicked!" 
END SUB

That transpiles to plain JavaScript — no build step, runs directly in the browser (or under Node for console-only programs, complete with PRINT/INPUT).

Still polishing before a proper release — more widgets and events are next — but curious what fellow BASIC folks think of the approach. Screenshot attached.

https://rcbasic.freeforums.net/thread/957/rcbasic-v4-9-out?page=1&scrollTo=9382

The author of the language is really diligent. 

Ha...I want to know whether there will be a big change in version 5.0.

"With the recent v0.7.0-alpha release a few weeks ago, Basic4GLj is 99% "done" and the next release will be focused on getting the project to an official 1.0 release 🎊 🥳 🎉

Significant progress has been made getting a plugin SDK put together to call the Basic4GL Java port complete, with the next few weeks being focused on getting docs, examples, and the settings UI all in place.

🎉 June Highlights 🎉

• v0.7.0-alpha release
• Shoutout to @laserswald for help with testing

🚧 In Progress 🚧

• Plugin SDK"

{ https://github.com/NateIsStalling/Basic4GLj/discussions/92 }

Quick summary: f-string interpolation, ISSET(), implicit line continuation,  a built-in HTTP listener, and a new SQLite tutorial.

## Get It

Download at: https://ekbass.github.io/BazzBasic/

## FSTRING()

Allows you to embed variables and constants directly to string.

LET name$ = "Krisu"
LET LEVEL# = 5
PRINT FSTRING("Hello {{-name$-}}, level {{-LEVEL#-}}")
' Output: Hello Krisu, level 5

See more: https://ekbass.github.io/BazzBasic/manual/#/string_functions?id=fstringtemplate

## ISSET()

Returns 1 if the named variable ($) or constant (#) is declared, 0 otherwise. Useful for guarding optional parameters, checking whether LET has run on a code path, or branching on configuration values.

LET a$ = "hello"
LET b$                  ' declared with no value
LET MAX# = 100
PRINT ISSET(a$)         ' 1
PRINT ISSET(b$)         ' 1  (LET declares it even without a value)
PRINT ISSET(MAX#)       ' 1
PRINT ISSET(undef$)     ' 0
PRINT ISSET(UNDEF#)     ' 0

See more: https://ekbass.github.io/BazzBasic/manual/#/other_functions?id=issetname

## Implicit line continuation

Long expressions and statements can be split across multiple lines. BazzBasic figures this out automatically — there is no special continuation character to remember (no \, no _, no &).

LET total$ = price$ * count$ -
             discount$
LET msg$ = "Hello, " +
           name$ +
           "!"
IF score$ >= 0 AND
   score$ <= 100 THEN
    PRINT "Valid score"
END IF
LET counter$ +=
    step$

See more: https://ekbass.github.io/BazzBasic/manual/#/control-flow?id=line-continuation

## HTTP LISTEN

BazzBasic can act as a small local HTTP server to receive POST requests from a browser-side HTML page or other tooling. The intended use is local-only glue: a static HTML page on the user's machine talks to BazzBasic via fetch().

See more: https://ekbass.github.io/BazzBasic/manual/#/network?id=http-server-listen

## BazzBasic and SQLite-tutorial added to manual

SQLite is a small, fast, file-based database engine that fits BazzBasic perfectly: no server to install, no daemon to manage, and the whole database lives in a single file you can copy, back up, or delete like any other. This page shows how to use it from BazzBasic without any external library — we just call the official sqlite3 command-line tool through SHELL().

See more: https://ekbass.github.io/BazzBasic/manual/#/sqlite

## BazzBasic 1.5?

For BazzBasic version 1.5 the main planned feature is finally GamePad support 

Summer is the hottest season for my second job, so BazzBasic development will be on hold for a little while after version 1.5, at least for the biggest events.

In addition, I also want to develop something myself using it, although I don't know what yet.

But once autumn hits the door, development continues as before.

You are welcome to share your thoughts, feedbacks, or opinions on them.

https://huggingface.co/datasets/EkBass/BazzBasic

Hi...good news. I have talked with a member of the development team of SmallBASIC:
/post/15957060

This member has two games made with SmallBASIC and old version of Raylib:
/__site/joe7m.itch.io/asteroids-for-smallbasic
/__site/joe7m.itch.io/bug-escape

- DRAWSTRING & LOADFONT — render TTF text directly in graphics mode (no more flickering!)
- ROWCOUNT — count array rows
- ARGCOUNT & ARGS() — access command-line arguments
- Compound assignment operators: +=, -=, *=, /=
- INSTR() now supports case-insensitive mode
- Math constants now use `#` suffix: PI#, HPI#, QPI#, TAU#
- IDE improvements: new file template, Compile as Exe/Lib from menu, Check for Updates, Beginner's Guide link
- Bugfix: early RETURN inside FOR loop no longer leaves function scope dirty

Breaking changes: PI/, HPI, QPI & TAU → add `#` suffix to keep consistency

Download: https://github.com/EkBass/BazzBasic/releases/tag/BazzBasic_1.3
Homepage: https://ekbass.github.io/BazzBasic/

**What's new:**

- `BBVER#` — built-in constant returning the running BazzBasic version

- `JOIN dest$, src1$, src2$` — merge two arrays (src2 overwrites on key conflict)

- `CURPOS("row"/"col")` — read current cursor position (1-based)

- `PRG_ROOT#` — renamed from `ROOT#` *(breaking change — update your code!)*

- **Bugfix:** `SCREEN` can now be called more than once without crashing

This guide covers everything you need to get started: variables, loops, conditions,  functions, file handling, JSON, networking, graphics, sound, and more. 

Each chapter builds on the last, with working example programs throughout.

This is not a complete reference. It is a starting point.  

The full BazzBasic manual covers everything else.

Download: https://github.com/EkBass/BazzBasic/releases/tag/BazzBasic_1.1

# News and changes

These changes are about the current source code. These are effected once new binary release is published

## Mar 2026

## 22nd Mar 2026

Released as version 1.1

## 22nd Mar 2026

At Rosetta code I got inspired to create pendulum animation.

https://github.com/EkBass/BazzBasic/blob/main/Examples/pendulum_animation.bas

## 21st Mar 2026

BazzBasic-AI_guide.md is a tutorial for modern AI's. With it, AI can easily teach the user how to use BazzBasic.

Just download the file, attach it as project file or via prompt to AI and you are cool to go.  

https://github.com/EkBass/BazzBasic/discussions/26

---

Unfortunately, the GamePad support I planned didn't make it to version 1.1

The reason is that the SDL2 library has been having problems for some time, especially with Bluetooth gamepads.

I didn't want to do something half-hearted, so the gamepad support is now on hold until SDL2 gets its library back in condition.

Instead, I added three other functions that I've had in mind for some time: BASE64ENCODE, BASE64DECODE and SHA256

## 21st Mar 2026

Added JSON support: `ASJSON`, `ASARRAY`, `LOADJSON`, `SAVEJSON`

```vb

DIM data$

data$("name") = "Alice"

data$("score") = 9999

data$("address,city") = "New York"

LET json$ = ASJSON(data$)

' Output: {"name":"Alice","score":9999,"address":{"city":"New York"}}

DIM back$

LET count$ = ASARRAY(back$, json$)

PRINT back$("name")         ' Alice

PRINT back$("address,city") ' New York

SAVEJSON data$, "save.json"

DIM loaded$

LOADJSON loaded$, "save.json"

```

Added `BASE64ENCODE`, `BASE64DECODE` and `SHA256`

```vb

LET encoded$ = BASE64ENCODE("Hello, World!")

PRINT encoded$              ' SGVsbG8sIFdvcmxkIQ==

LET decoded$ = BASE64DECODE(encoded$)

PRINT decoded$              ' Hello, World!

LET hash$ = SHA256("password123")

PRINT hash$                 ' ef92b778... (64-char lowercase hex)

```

---

## 14th Mar 2026

## Sound system fix — parallel audio playback

**Problem:** The old implementation loaded MP3/OGG/FLAC files with `Mix_LoadMUS()` which uses the SDL2_mixer's global Music channel — only one sound at a time.

**Fixes:**

- All sounds are now loaded with `Mix_LoadWAV()` → play on their own Mix_Channels in parallel

- `SDL_INIT_AUDIO` added to `SDL_Init()` call in `Graphics.cs`

- `SoundManager` calls `SDL_Init` + `SDL_InitSubSystem` to ensure audio subsystem even without `SCREEN` command

- `SDL_AUDIODRIVER=directsound` set in `Program.cs` to work around WASAPI issues (Nahimic middleware causes "Invalid Handle" error in WASAPI)

- `PlayOnceWait` gets 50ms delay before polling loop due to DirectSound startup delay

## 7th Mar 2026

Added HTTP support for LOADIMAGE

### LOADIMAGE with url

LOADIMAGE now supports loading via HTTP.

```

Added WAITKEY() function. 

## WAITKEY

Halts the execution until requested key is pressed.

```vb

' Wait just the ENTER key

PRINT "ENTER"

PRINT WAITKEY(KEY_ENTER#) ' output: 13

' Wait any of "a", "b" or "esc" keys

PRINT "A, B or ESC"

PRINT WAITKEY(KEY_A#, KEY_B#, KEY_ESC#) ' output: depends of your choice of key

PRINT "Press any key..." 

LET a$ = WAITKEY()

PRINT a$ ' output: val of key you pressed

```

## 2nd Mar 2026

Added SHELL feature

```vb

' SHELL arg$, timeout$

' Sends a command to the system command interpreter  

' Param *timeout$* is optional. If not given, standard 5000 milliseconds used for timeout.

' with default timeout option

LET a$ = SHELL("dir *.txt")

PRINT a$

' sets timeout to 2 seconds

' 1000ms = 1 second etc.

LET a$ = SHELL("dir *.txt", 2000)

PRINT a$

```

• Vehicle Actors - These are raycast vehicle objects in bullet that have transforms applied to actors for the chassis and wheels
• Composite Actors - These actors have compound shapes for making shapes more complex
• Sprites can now add child sprites
• New vector math functions
• Added the ACTOR_SHAPE_IMPACT_MESH shape
• Added a function for saving images to *.bmp files
• Sprites now keeps the source image that was set when an animation was made. This is also fully implemented in the Nirvana 2D editor.
• There are a few new examples that show off some of the new features.
• The manual has a new theme.
• There are new entries in the manual covering sprites and 3D graphics more indepth.

[ /__site/n00bcode.itch.io/rcbasic-basic-programming-language-for-games/devlog/1425833/rcbasic-v48-released  ]
[ https://rcbasic.freeforums.net/thread/944/rcbasic-v4-8-out?page=1&scrollTo=9257 ]

> File: https://github.com/EkBass/BazzBasic/blob/main/changes.md

# BazzBasic 1.0 released

Download Github release or source of BazzBasic: https://github.com/EkBass/BazzBasic/releases/tag/BazzBasic

## Feb 2026

## 22nd Feb. 2026

- Released as version 1.0, source and binary

## 21st Feb. 2026

- FILEREAD and FILEWRITE now supports arrays too.

- **Example with array:**

```vb

LET FILENAME# = "array.txt"

DIM a$

a$("first") = 1

a$("second") = 2

a$("third") = 3

a$("fourth") = "Four"

a$("fourth", "temp") = "Temp"

FileWrite FILENAME#, a$

DIM b$ = FileRead(FILENAME#)

PRINT b$("fourth", "temp") ' Output: Temp

```

**array.txt content:**

```

first=1

second=2

third=3

fourth=Four

fourth,temp=Temp

```

## 21st Feb. 2026

- Added statements HTTPPOST and HTTPGET. These statements allow you to send HTTP POST and GET requests to a specified URL and retrieve the response as a string.

```vb

DIM response$

LET response$ = HTTPGET("https://httpbin.org/get")

PRINT response$

DIM postResult$

LET postResult$ = HTTPPOST("https://httpbin.org/post", "{""key"":""value""}")

PRINT postResult$

```

- Added statement LOADSHEET(<path>, <size x>, <size t>)

```vb

REM ============================================

REM LOADSHEET demo: countdown 9 -> 0

REM sheet_numbers.png: 640x256, 128x128 sprites

REM Sprite 1=0, 2=1, 3=2 ... 10=9

REM ============================================

SCREEN 640, 480, "Countdown!"

DIM sprites$

LOADSHEET sprites$, 128, 128, "examples/sheet_numbers.png"

REM Center position for a 128x128 sprite on 640x480 screen

LET x# = 256

LET y# = 176

REM Count down from 9 to 0

REM Sprite index = number + 1  (sprite 10 = digit 9, sprite 1 = digit 0)

FOR i$ = 9 TO 0 STEP -1

    CLS

    LET spriteIndex$

    LET spriteIndex$ = i$ + 1

    MOVESHAPE sprites$(spriteIndex$), x#, y#

    DRAWSHAPE sprites$(spriteIndex$)

    SLEEP 500

NEXT

END

```

- - Added FULLSCREEN TRUE/FALSE. Enables or disables borderless fullscreen mode.

```vb

SCREEN 640, 480, "My title"

FULLSCREEN TRUE   ' borderless fullscreen on

FULLSCREEN FALSE  ' Windowed mode

```

## 14th Feb. 2026

- Fixed INPUT and LINE INPUT when using GFX. Binary release also updated

## 14th Feb. 2026

- Added KEYDOWN(<key constant#>) function with what it's possible to check state of all key constants

- Added key constants to all keys I could imagine. Will add more if figured out some is missing

**BazzBasic 0.9** is now available as binary and source.

## What's New in 0.9

The latest update brings some additions aimed for game developers.

**New Math & Utility Functions:**

- `LERP(start, end, t)` — Linear interpolation between two values

- `DISTANCE()` — Calculate 2D or 3D distances with a single call

- `CLAMP(n, min, max)` — Keep values within bounds without verbose IF chains

- `BETWEEN(value, min, max)` — Quick range checking that returns TRUE/FALSE

- `EULER` — The mathematical constant *e* ≈ 2.718281828459045

- `TAU` and `QPI` — Convenient constants for 2π and π/4

**Graphics Enhancement:**

- `VSYNC(TRUE/FALSE)` — Control vertical sync for smooth rendering or uncapped frame rates

## Roadmap to 1.0

The next milestone will introduce some interesting things:

**HTTP Support** — Make GET and POST requests directly from BazzBasic. Fetch data from APIs, download files, or send data to web services.

**Sprite Sheets** — `LOADSHEET(filename, width, height)` will slice sprite sheet images into individual frames stored in an array, making 2D game animation easier.

**Under Consideration:**

- Joystick/gamepad support for game input

- Native JSON and XML parsing to and from arrays

## Get BazzBasic

- **Homepage:** https://ekbass.github.io/BazzBasic/

- **Source:** https://github.com/EkBass/BazzBasic/tree/main

- **Documentation:** https://ekbass.github.io/BazzBasic/manual/#/

- **Discussions:** https://ekbass.github.io/BazzBasic/communities.html

This sub-forum is small but moderately active.  It is a lively space for BASIC dialect enthusiasts and is ideal for those who enjoy experimenting with retro programming languages, sharing demos, or joining niche jams. It doesn’t have the scale of mainstream programming community but the atmosphere in this sub-forum makes interactions more direct and creative. Sure!

# BazzBasic version 0.8

Key issues, news and changes from 0.7

## NAudio to SDL2

This change has been done. It was actually easier to do what I expected.  

Audio features works just as with version 0.7

## RAD & DEG

Added keywords **RAD** & **DEG**

## PI & HPI

**PI** returns a hard coded value of *3.141592653589793*  

**HPI** returns a hard coded value of *1.5707963267948966*

These both are commonly and often used when playing with graphics. Hard coding them makes things much faster.

## Fast Trigonometry (Lookup Tables)

For graphics-intensive applications (games, raycasting, animations), BazzBasic provides fast trigonometric functions using pre-calculated lookup tables. These are significantly faster than standard `SIN`/`COS` functions but have 1-degree precision.

**Performance:** ~20x faster than `SIN(RAD(x))` for integer degree values.  

**Memory:** Uses ~5.6 KB when enabled

### FastTrig(<param>)

Enables or disables fast trigonometry lookup tables.

**Parameters:**

- `TRUE` (or any non-zero value) - Creates lookup tables

- `FALSE` (or 0) - Destroys lookup tables and frees memory

### FastSin(angle)

Returns the sine of an angle (in degrees) using a lookup table.

**Parameters:**

- `angle` - Angle in degrees (automatically normalized to 0-359)

**Returns:** Sine value (-1.0 to 1.0)

**Precision:** 1 degree (sufficient for most games and graphics)

```vb

FastTrig(TRUE)

PRINT FastSin(0)    ' Output: 0

PRINT FastSin(90)   ' Output: 1

PRINT FastSin(180)  ' Output: 0

PRINT FastSin(270)  ' Output: -1

' Angles are automatically wrapped

PRINT FastSin(450)  ' Same as FastSin(90) = 1

PRINT FastSin(-90)  ' Same as FastSin(270) = -1

FastTrig(FALSE)

```

### FastCos(angle)

Returns the cosine of an angle (in degrees) using a lookup table.

**Parameters:**

- `angle` - Angle in degrees (automatically normalized to 0-359)

**Returns:** Cosine value (-1.0 to 1.0)

**Precision:** 1 degree (sufficient for most games and graphics)

```vb

FastTrig(TRUE)

PRINT FastCos(0)    ' Output: 1

PRINT FastCos(90)   ' Output: 0

PRINT FastCos(180)  ' Output: -1

PRINT FastCos(270)  ' Output: 0

' Use in raycasting

FOR angle$ = 0 TO 359

    LET dx$ = FastCos(angle$)

    LET dy$ = FastSin(angle$)

    ' Cast ray in direction (dx, dy)

NEXT

FastTrig(FALSE)

```

### FastRad(angle)

Converts degrees to radians using an optimized formula.

**Parameters:**

- `angle` - Angle in degrees (automatically normalized to 0-359)

**Returns:** Angle in radians

**Note:** This function doesn't require `FastTrig(TRUE)` but is included for consistency.

```vb

PRINT FastRad(90)   ' Output: 1.5707963267948966 (HPI)

PRINT FastRad(180)  ' Output: 3.141592653589793 (PI)

PRINT FastRad(360)  ' Output: 6.283185307179586 (2*PI)

```

## Download

Source and Windows binaries https://ekbass.github.io/BazzBasic/

## Version 0.9

For version 0.9, I'm focusing on making sure that the metafiles etc. are in accordance with Windows and Avast reducing warnings when BazzBasic is run for the first time.

The easiest way would probably be to get an account in the Microsoft Store, but it costs money and I don't want to do that since it's a free open source project.

Most of the metafiles are already in order, but GitHub's own "release" method would help even more. However, I haven't had time to learn it yet.

Of course, bug hunting and fine-tuning are definitely expected with version 0.9.

*Kristian Virtanen*  

*krisu.virtanen@gmail.com*  

*https://ekbass.github.io/BazzBasic/*

A new BASIC dialect was released:
https://ekbass.github.io/BazzBasic/
( https://rcbasic.freeforums.net/thread/936/bazzbasic-win-x64?page=1&scrollTo=9178 )

QBJS(/__site/boxgm.itch.io/qbjs) is a modern re‑implementation of QBASIC that runs in the browser via JavaScript. It allows retro BASIC code to be executed online, making it accessible without installing old interpreters. Technically, it’s clever because it bridges retro programming with modern web tech. Running QBASIC code in a browser is a neat feat, lowering the barrier for hobbyists.

There is no doubt that its appeal is strongest among retro computing enthusiasts. QBJS is not mainstream popular, but it’s quite vibrant for such a new tool. I have confidence in QBJS’s future as a sustainable retro programming tool.  Maybe it will not rival Contruct or Godot in popularity but it will be a very specialized tool with a lot of loyal fans.

https://rcbasic.freeforums.net/post/9173/thread

In my view, RCBasic is a very nice software and I encourage BASIC hobbyists to download to try this free software.. 

If you learned to program in the 80s or 90s, chances are your first line of code looked something like this:

 PRINT "Hello, World!"

To many, BASIC feels like a relic of computing’s early days—an outdated teaching tool overshadowed by modern languages like Python or JavaScript. But that assumption couldn't be more wrong. BASIC never disappeared. It diversified. It evolved. And today, it lives on in a wide range of powerful, practical dialects still being used to build games, web tools, business systems, and more.

The above part is only the first part of the article. The whole article is on the following page. Being an amateur or hobbyist, I agree with the points of the article. The author still has confidence in BASIC. The author is the developer of the language PlayBASIC and has other very interesting articles about BASIC on the blog:

 https://kevinpicone.com/?page=Articles.84.basic-isnt-dead-it-just-grew-up 

/__site/larrybtoys.itch.io/

I still remember that the developer(Larry) is the winner of BASIC Jam No.6. Larry's entry is outstanding: 

/__site/larrybtoys.itch.io/120-seconds-to-save-the-world

Since Larry used GFA-BASIC to make so many games, I believe that GFA-BASIC should be a very nice language. However, I am surprised because GFA-BASIC is not a 64-bit compiler. Anyway, I encourage people to download the games to play and also try  the language and the compiler. .